/****************************************************************************
**
** 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_qtdatavisualization_python.h"

#include <QtDataVisualization/qutils.h>


// Extra includes
#include <qutils.h>

// Current module's type array.
PyTypeObject **SbkPySide6_QtDataVisualizationTypes = nullptr;
// Current module's PyObject pointer.
PyObject *SbkPySide6_QtDataVisualizationModuleObject = nullptr;
// Current module's converter array.
SbkConverter **SbkPySide6_QtDataVisualizationTypeConverters = nullptr;
void cleanTypesAttributes() {
    for (int i = 0, imax = SBK_QtDataVisualization_IDX_COUNT; i < imax; i++) {
        PyObject *pyType = reinterpret_cast<PyObject *>(SbkPySide6_QtDataVisualizationTypes[i]);
        Shiboken::AutoDecRef attrName(Py_BuildValue("s", "staticMetaObject"));
        if (pyType && PyObject_HasAttr(pyType, attrName))
            PyObject_SetAttr(pyType, attrName, Py_None);
    }
}
// Global functions ------------------------------------------------------------
static PyObject *SbkQtDataVisualizationModule_qDefaultSurfaceFormat(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtDataVisualization.qDefaultSurfaceFormat";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

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

    // Function signature not found.
    if (overloadId == -1) goto SbkQtDataVisualizationModule_qDefaultSurfaceFormat_TypeError;

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

        if (!PyErr_Occurred()) {
            // qDefaultSurfaceFormat(bool)
            QSurfaceFormat cppResult = qDefaultSurfaceFormat(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QSURFACEFORMAT_IDX], &cppResult);
        }
    }

    if (PyErr_Occurred() || !pyResult) {
        Py_XDECREF(pyResult);
        return {};
    }
    return pyResult;

    SbkQtDataVisualizationModule_qDefaultSurfaceFormat_TypeError:
        Shiboken::setErrorAboutWrongArguments(pyArg, fullName, errInfo);
        return {};
}


static PyMethodDef QtDataVisualization_methods[] = {
    {"qDefaultSurfaceFormat", reinterpret_cast<PyCFunction>(SbkQtDataVisualizationModule_qDefaultSurfaceFormat), METH_O},
    {0} // Sentinel
};

// Classes initialization functions ------------------------------------------------------------
void init_QSurfaceDataItem(PyObject *module);
void init_QScatterDataItem(PyObject *module);
void init_QBarDataItem(PyObject *module);
void init_QAbstract3DGraph(PyObject *module);
void init_Q3DSurface(PyObject *module);
void init_Q3DScatter(PyObject *module);
void init_Q3DBars(PyObject *module);
void init_QValue3DAxisFormatter(PyObject *module);
void init_QLogValue3DAxisFormatter(PyObject *module);
void init_QCustom3DItem(PyObject *module);
void init_QCustom3DVolume(PyObject *module);
void init_QCustom3DLabel(PyObject *module);
void init_QAbstractDataProxy(PyObject *module);
void init_QSurfaceDataProxy(PyObject *module);
void init_QItemModelSurfaceDataProxy(PyObject *module);
void init_QHeightMapSurfaceDataProxy(PyObject *module);
void init_QScatterDataProxy(PyObject *module);
void init_QItemModelScatterDataProxy(PyObject *module);
void init_QBarDataProxy(PyObject *module);
void init_QItemModelBarDataProxy(PyObject *module);
void init_QAbstract3DSeries(PyObject *module);
void init_QSurface3DSeries(PyObject *module);
void init_QScatter3DSeries(PyObject *module);
void init_QBar3DSeries(PyObject *module);
void init_QAbstract3DInputHandler(PyObject *module);
void init_Q3DInputHandler(PyObject *module);
void init_QTouch3DInputHandler(PyObject *module);
void init_QAbstract3DAxis(PyObject *module);
void init_QValue3DAxis(PyObject *module);
void init_QCategory3DAxis(PyObject *module);
void init_Q3DTheme(PyObject *module);
void init_Q3DScene(PyObject *module);
void init_Q3DObject(PyObject *module);
void init_Q3DLight(PyObject *module);
void init_Q3DCamera(PyObject *module);

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

// Module initialization ------------------------------------------------------------

// Primitive Type converters.

// C++ to Python conversion for primitive type 'QBarDataArray'.
static PyObject *QBarDataArray_CppToPython_QBarDataArray(const void *cppIn)
{
    auto &cppInRef = *reinterpret_cast<::QBarDataArray *>(const_cast<void *>(cppIn));
    // TEMPLATE - cppqlistofptrtoqlists_to_py_conversion - START
    const Py_ssize_t rowCount = cppInRef.size();
    PyObject* pyOut = PyList_New(rowCount);
    for (Py_ssize_t r = 0; r < rowCount; ++r) {
        const QList<QBarDataItem> *row = cppInRef.at(r);
        const Py_ssize_t columnCount = row->size();
        PyObject *pyRow = PyList_New(columnCount);
        for (Py_ssize_t c = 0; c < columnCount; ++c) {
            const QBarDataItem &cppItem = row->at(c);
            PyList_SET_ITEM(pyRow, c, Shiboken::Conversions::copyToPython(SbkPySide6_QtDataVisualizationTypes[SBK_QBARDATAITEM_IDX], &cppItem));
        }
        PyList_SET_ITEM(pyOut, r, pyRow);
    }
    return pyOut;
    // TEMPLATE - cppqlistofptrtoqlists_to_py_conversion - END

}
// Python to C++ conversions for type 'QBarDataArray'.
static void PySequence_PythonToCpp_QBarDataArray(PyObject *pyIn, void *cppOut)
{
    // TEMPLATE - py_to_cppqlistofptrtoqlists_conversion - START
    const Py_ssize_t rowCount = PySequence_Size(pyIn);
    QBarDataArray &result = *reinterpret_cast<::QBarDataArray *>(cppOut);
    result.reserve(rowCount);
    for (Py_ssize_t r = 0; r < rowCount; ++r) {
        Shiboken::AutoDecRef rowItem(PySequence_GetItem(pyIn, r));
        const Py_ssize_t columnCount = PySequence_Size(rowItem);
        auto *row = new QList<QBarDataItem>;
        row->reserve(columnCount);
        for (Py_ssize_t c = 0; c < columnCount; ++c) {
           Shiboken::AutoDecRef pyItem(PySequence_GetItem(rowItem, c));
           ::QBarDataItem v;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtDataVisualizationTypes[SBK_QBARDATAITEM_IDX], pyItem, &(v));
           row->append(v);
        }
        result.append(row);
    }
    // TEMPLATE - py_to_cppqlistofptrtoqlists_conversion - END

}
static PythonToCppFunc is_PySequence_PythonToCpp_QBarDataArray_Convertible(PyObject *pyIn)
{
    if (Shiboken::String::checkIterable(pyIn))
        return PySequence_PythonToCpp_QBarDataArray;
    return {};
}

// C++ to Python conversion for primitive type 'QSurfaceDataArray'.
static PyObject *QSurfaceDataArray_CppToPython_QSurfaceDataArray(const void *cppIn)
{
    auto &cppInRef = *reinterpret_cast<::QSurfaceDataArray *>(const_cast<void *>(cppIn));
    // TEMPLATE - cppqlistofptrtoqlists_to_py_conversion - START
    const Py_ssize_t rowCount = cppInRef.size();
    PyObject* pyOut = PyList_New(rowCount);
    for (Py_ssize_t r = 0; r < rowCount; ++r) {
        const QList<QSurfaceDataItem> *row = cppInRef.at(r);
        const Py_ssize_t columnCount = row->size();
        PyObject *pyRow = PyList_New(columnCount);
        for (Py_ssize_t c = 0; c < columnCount; ++c) {
            const QSurfaceDataItem &cppItem = row->at(c);
            PyList_SET_ITEM(pyRow, c, Shiboken::Conversions::copyToPython(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACEDATAITEM_IDX], &cppItem));
        }
        PyList_SET_ITEM(pyOut, r, pyRow);
    }
    return pyOut;
    // TEMPLATE - cppqlistofptrtoqlists_to_py_conversion - END

}
// Python to C++ conversions for type 'QSurfaceDataArray'.
static void PySequence_PythonToCpp_QSurfaceDataArray(PyObject *pyIn, void *cppOut)
{
    // TEMPLATE - py_to_cppqlistofptrtoqlists_conversion - START
    const Py_ssize_t rowCount = PySequence_Size(pyIn);
    QSurfaceDataArray &result = *reinterpret_cast<::QSurfaceDataArray *>(cppOut);
    result.reserve(rowCount);
    for (Py_ssize_t r = 0; r < rowCount; ++r) {
        Shiboken::AutoDecRef rowItem(PySequence_GetItem(pyIn, r));
        const Py_ssize_t columnCount = PySequence_Size(rowItem);
        auto *row = new QList<QSurfaceDataItem>;
        row->reserve(columnCount);
        for (Py_ssize_t c = 0; c < columnCount; ++c) {
           Shiboken::AutoDecRef pyItem(PySequence_GetItem(rowItem, c));
           ::QSurfaceDataItem v;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACEDATAITEM_IDX], pyItem, &(v));
           row->append(v);
        }
        result.append(row);
    }
    // TEMPLATE - py_to_cppqlistofptrtoqlists_conversion - END

}
static PythonToCppFunc is_PySequence_PythonToCpp_QSurfaceDataArray_Convertible(PyObject *pyIn)
{
    if (Shiboken::String::checkIterable(pyIn))
        return PySequence_PythonToCpp_QSurfaceDataArray;
    return {};
}


// Container Type converters.

// C++ to Python conversion for container type 'QList<QCustom3DItem* >'.
static PyObject *_QList_QCustom3DItemPTR__CppToPython__QList_QCustom3DItemPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QCustom3DItem* > *>(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_QtDataVisualizationTypes[SBK_QCUSTOM3DITEM_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QCustom3DItemPTR__PythonToCpp__QList_QCustom3DItemPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QCustom3DItem* > *>(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;
        }
        ::QCustom3DItem* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QCUSTOM3DITEM_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QCustom3DItemPTR__PythonToCpp__QList_QCustom3DItemPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QCUSTOM3DITEM_IDX], pyIn))
        return _QList_QCustom3DItemPTR__PythonToCpp__QList_QCustom3DItemPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QAbstract3DInputHandler* >'.
static PyObject *_QList_QAbstract3DInputHandlerPTR__CppToPython__QList_QAbstract3DInputHandlerPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QAbstract3DInputHandler* > *>(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_QtDataVisualizationTypes[SBK_QABSTRACT3DINPUTHANDLER_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QAbstract3DInputHandlerPTR__PythonToCpp__QList_QAbstract3DInputHandlerPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QAbstract3DInputHandler* > *>(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;
        }
        ::QAbstract3DInputHandler* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QABSTRACT3DINPUTHANDLER_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QAbstract3DInputHandlerPTR__PythonToCpp__QList_QAbstract3DInputHandlerPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QABSTRACT3DINPUTHANDLER_IDX], pyIn))
        return _QList_QAbstract3DInputHandlerPTR__PythonToCpp__QList_QAbstract3DInputHandlerPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Q3DTheme* >'.
static PyObject *_QList_Q3DThemePTR__CppToPython__QList_Q3DThemePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Q3DTheme* > *>(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_QtDataVisualizationTypes[SBK_Q3DTHEME_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Q3DThemePTR__PythonToCpp__QList_Q3DThemePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Q3DTheme* > *>(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;
        }
        ::Q3DTheme* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_Q3DTHEME_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Q3DThemePTR__PythonToCpp__QList_Q3DThemePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_Q3DTHEME_IDX], pyIn))
        return _QList_Q3DThemePTR__PythonToCpp__QList_Q3DThemePTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QValue3DAxis* >'.
static PyObject *_QList_QValue3DAxisPTR__CppToPython__QList_QValue3DAxisPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QValue3DAxis* > *>(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_QtDataVisualizationTypes[SBK_QVALUE3DAXIS_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QValue3DAxisPTR__PythonToCpp__QList_QValue3DAxisPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QValue3DAxis* > *>(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;
        }
        ::QValue3DAxis* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QVALUE3DAXIS_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QValue3DAxisPTR__PythonToCpp__QList_QValue3DAxisPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QVALUE3DAXIS_IDX], pyIn))
        return _QList_QValue3DAxisPTR__PythonToCpp__QList_QValue3DAxisPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QSurface3DSeries* >'.
static PyObject *_QList_QSurface3DSeriesPTR__CppToPython__QList_QSurface3DSeriesPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QSurface3DSeries* > *>(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_QtDataVisualizationTypes[SBK_QSURFACE3DSERIES_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QSurface3DSeriesPTR__PythonToCpp__QList_QSurface3DSeriesPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QSurface3DSeries* > *>(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;
        }
        ::QSurface3DSeries* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACE3DSERIES_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QSurface3DSeriesPTR__PythonToCpp__QList_QSurface3DSeriesPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACE3DSERIES_IDX], pyIn))
        return _QList_QSurface3DSeriesPTR__PythonToCpp__QList_QSurface3DSeriesPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QScatter3DSeries* >'.
static PyObject *_QList_QScatter3DSeriesPTR__CppToPython__QList_QScatter3DSeriesPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QScatter3DSeries* > *>(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_QtDataVisualizationTypes[SBK_QSCATTER3DSERIES_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QScatter3DSeriesPTR__PythonToCpp__QList_QScatter3DSeriesPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QScatter3DSeries* > *>(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;
        }
        ::QScatter3DSeries* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QSCATTER3DSERIES_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QScatter3DSeriesPTR__PythonToCpp__QList_QScatter3DSeriesPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QSCATTER3DSERIES_IDX], pyIn))
        return _QList_QScatter3DSeriesPTR__PythonToCpp__QList_QScatter3DSeriesPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QAbstract3DAxis* >'.
static PyObject *_QList_QAbstract3DAxisPTR__CppToPython__QList_QAbstract3DAxisPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QAbstract3DAxis* > *>(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_QtDataVisualizationTypes[SBK_QABSTRACT3DAXIS_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QAbstract3DAxisPTR__PythonToCpp__QList_QAbstract3DAxisPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QAbstract3DAxis* > *>(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;
        }
        ::QAbstract3DAxis* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QABSTRACT3DAXIS_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QAbstract3DAxisPTR__PythonToCpp__QList_QAbstract3DAxisPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QABSTRACT3DAXIS_IDX], pyIn))
        return _QList_QAbstract3DAxisPTR__PythonToCpp__QList_QAbstract3DAxisPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QBar3DSeries* >'.
static PyObject *_QList_QBar3DSeriesPTR__CppToPython__QList_QBar3DSeriesPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QBar3DSeries* > *>(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_QtDataVisualizationTypes[SBK_QBAR3DSERIES_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QBar3DSeriesPTR__PythonToCpp__QList_QBar3DSeriesPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QBar3DSeries* > *>(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;
        }
        ::QBar3DSeries* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtDataVisualizationTypes[SBK_QBAR3DSERIES_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QBar3DSeriesPTR__PythonToCpp__QList_QBar3DSeriesPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QBAR3DSERIES_IDX], pyIn))
        return _QList_QBar3DSeriesPTR__PythonToCpp__QList_QBar3DSeriesPTR_;
    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<float >'.
static PyObject *_QList_float__CppToPython__QList_float_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<float > *>(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<float>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_float__PythonToCpp__QList_float__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<float>(), pyIn))
        return _QList_float__PythonToCpp__QList_float_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_uchar__PythonToCpp__QList_uchar__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), pyIn))
        return _QList_uchar__PythonToCpp__QList_uchar_;
    return {};
}

// C++ to Python conversion for container type 'QList<unsigned int >'.
static PyObject *_QList_unsignedint__CppToPython__QList_unsignedint_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<unsigned 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<unsigned int>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

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

// C++ to Python conversion for container type 'QList<QImage* >'.
static PyObject *_QList_QImagePTR__CppToPython__QList_QImagePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QImage* > *>(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_QtGuiTypes[SBK_QIMAGE_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QImagePTR__PythonToCpp__QList_QImagePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QImage* > *>(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;
        }
        ::QImage* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtGuiTypes[SBK_QIMAGE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QImagePTR__PythonToCpp__QList_QImagePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QIMAGE_IDX], pyIn))
        return _QList_QImagePTR__PythonToCpp__QList_QImagePTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QSurfaceDataItem >'.
static PyObject *_QList_QSurfaceDataItem__CppToPython__QList_QSurfaceDataItem_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QSurfaceDataItem > *>(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_QtDataVisualizationTypes[SBK_QSURFACEDATAITEM_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QSurfaceDataItem__PythonToCpp__QList_QSurfaceDataItem_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QSurfaceDataItem > *>(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;
        }
        ::QSurfaceDataItem cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACEDATAITEM_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QSurfaceDataItem__PythonToCpp__QList_QSurfaceDataItem__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QSURFACEDATAITEM_IDX], pyIn))
        return _QList_QSurfaceDataItem__PythonToCpp__QList_QSurfaceDataItem_;
    return {};
}

// C++ to Python conversion for container type 'QList<QScatterDataItem >'.
static PyObject *_QList_QScatterDataItem__CppToPython__QList_QScatterDataItem_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QScatterDataItem > *>(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_QtDataVisualizationTypes[SBK_QSCATTERDATAITEM_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QScatterDataItem__PythonToCpp__QList_QScatterDataItem_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QScatterDataItem > *>(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;
        }
        ::QScatterDataItem cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtDataVisualizationTypes[SBK_QSCATTERDATAITEM_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QScatterDataItem__PythonToCpp__QList_QScatterDataItem__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QSCATTERDATAITEM_IDX], pyIn))
        return _QList_QScatterDataItem__PythonToCpp__QList_QScatterDataItem_;
    return {};
}

// C++ to Python conversion for container type 'QList<QBarDataItem >'.
static PyObject *_QList_QBarDataItem__CppToPython__QList_QBarDataItem_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QBarDataItem > *>(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_QtDataVisualizationTypes[SBK_QBARDATAITEM_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QBarDataItem__PythonToCpp__QList_QBarDataItem_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QBarDataItem > *>(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;
        }
        ::QBarDataItem cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtDataVisualizationTypes[SBK_QBARDATAITEM_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QBarDataItem__PythonToCpp__QList_QBarDataItem__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtDataVisualizationTypes[SBK_QBARDATAITEM_IDX], pyIn))
        return _QList_QBarDataItem__PythonToCpp__QList_QBarDataItem_;
    return {};
}

// C++ to Python conversion for container type 'QList<QColor >'.
static PyObject *_QList_QColor__CppToPython__QList_QColor_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QColor > *>(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_QtGuiTypes[SBK_QCOLOR_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QColor__PythonToCpp__QList_QColor_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QColor > *>(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;
        }
        ::QColor cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtGuiTypes[SBK_QCOLOR_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QColor__PythonToCpp__QList_QColor__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QCOLOR_IDX], pyIn))
        return _QList_QColor__PythonToCpp__QList_QColor_;
    return {};
}

// C++ to Python conversion for container type 'QList<QLinearGradient >'.
static PyObject *_QList_QLinearGradient__CppToPython__QList_QLinearGradient_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QLinearGradient > *>(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_QtGuiTypes[SBK_QLINEARGRADIENT_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QLinearGradient__PythonToCpp__QList_QLinearGradient_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QLinearGradient > *>(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;
        }
        ::QLinearGradient cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtGuiTypes[SBK_QLINEARGRADIENT_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QLinearGradient__PythonToCpp__QList_QLinearGradient__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QLINEARGRADIENT_IDX], pyIn))
        return _QList_QLinearGradient__PythonToCpp__QList_QLinearGradient_;
    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     */ "QtDataVisualization",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ QtDataVisualization_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 *QtDataVisualization_SignatureStrings[] = {
    "PySide6.QtDataVisualization.qDefaultSurfaceFormat(antialias:bool)->PySide6.QtGui.QSurfaceFormat",
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_QtDataVisualization()
{
    if (SbkPySide6_QtDataVisualizationModuleObject != nullptr)
        return SbkPySide6_QtDataVisualizationModuleObject;
    {
        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_QtDataVisualization_IDX_COUNT];
    SbkPySide6_QtDataVisualizationTypes = cppApi;

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

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

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

    // Initialize classes in the type system
    init_QSurfaceDataItem(module);
    init_QScatterDataItem(module);
    init_QBarDataItem(module);
    init_QAbstract3DGraph(module);
    init_Q3DSurface(module);
    init_Q3DScatter(module);
    init_Q3DBars(module);
    init_QValue3DAxisFormatter(module);
    init_QLogValue3DAxisFormatter(module);
    init_QCustom3DItem(module);
    init_QCustom3DVolume(module);
    init_QCustom3DLabel(module);
    init_QAbstractDataProxy(module);
    init_QSurfaceDataProxy(module);
    init_QItemModelSurfaceDataProxy(module);
    init_QHeightMapSurfaceDataProxy(module);
    init_QScatterDataProxy(module);
    init_QItemModelScatterDataProxy(module);
    init_QBarDataProxy(module);
    init_QItemModelBarDataProxy(module);
    init_QAbstract3DSeries(module);
    init_QSurface3DSeries(module);
    init_QScatter3DSeries(module);
    init_QBar3DSeries(module);
    init_QAbstract3DInputHandler(module);
    init_Q3DInputHandler(module);
    init_QTouch3DInputHandler(module);
    init_QAbstract3DAxis(module);
    init_QValue3DAxis(module);
    init_QCategory3DAxis(module);
    init_Q3DTheme(module);
    init_Q3DScene(module);
    init_Q3DObject(module);
    init_Q3DLight(module);
    init_Q3DCamera(module);

    // Register converter for type 'PySide6.QtDataVisualization.QBarDataArray'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QBARDATAARRAY_IDX] = Shiboken::Conversions::createConverter(nullptr, QBarDataArray_CppToPython_QBarDataArray);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QBARDATAARRAY_IDX], "QBarDataArray");
    // Add user defined implicit conversions to type converter.
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QBARDATAARRAY_IDX],
        PySequence_PythonToCpp_QBarDataArray,
        is_PySequence_PythonToCpp_QBarDataArray_Convertible);

    // Register converter for type 'PySide6.QtDataVisualization.QSurfaceDataArray'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QSURFACEDATAARRAY_IDX] = Shiboken::Conversions::createConverter(nullptr, QSurfaceDataArray_CppToPython_QSurfaceDataArray);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QSURFACEDATAARRAY_IDX], "QSurfaceDataArray");
    // Add user defined implicit conversions to type converter.
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QSURFACEDATAARRAY_IDX],
        PySequence_PythonToCpp_QSurfaceDataArray,
        is_PySequence_PythonToCpp_QSurfaceDataArray_Convertible);


    // Register converter for type 'QList<QCustom3DItem*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCUSTOM3DITEMPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QCustom3DItemPTR__CppToPython__QList_QCustom3DItemPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCUSTOM3DITEMPTR_IDX], "QList<QCustom3DItem*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCUSTOM3DITEMPTR_IDX],
        _QList_QCustom3DItemPTR__PythonToCpp__QList_QCustom3DItemPTR_,
        is__QList_QCustom3DItemPTR__PythonToCpp__QList_QCustom3DItemPTR__Convertible);

    // Register converter for type 'QList<QAbstract3DInputHandler*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DINPUTHANDLERPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QAbstract3DInputHandlerPTR__CppToPython__QList_QAbstract3DInputHandlerPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DINPUTHANDLERPTR_IDX], "QList<QAbstract3DInputHandler*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DINPUTHANDLERPTR_IDX],
        _QList_QAbstract3DInputHandlerPTR__PythonToCpp__QList_QAbstract3DInputHandlerPTR_,
        is__QList_QAbstract3DInputHandlerPTR__PythonToCpp__QList_QAbstract3DInputHandlerPTR__Convertible);

    // Register converter for type 'QList<Q3DTheme*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_Q3DTHEMEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Q3DThemePTR__CppToPython__QList_Q3DThemePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_Q3DTHEMEPTR_IDX], "QList<Q3DTheme*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_Q3DTHEMEPTR_IDX],
        _QList_Q3DThemePTR__PythonToCpp__QList_Q3DThemePTR_,
        is__QList_Q3DThemePTR__PythonToCpp__QList_Q3DThemePTR__Convertible);

    // Register converter for type 'QList<QValue3DAxis*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QVALUE3DAXISPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QValue3DAxisPTR__CppToPython__QList_QValue3DAxisPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QVALUE3DAXISPTR_IDX], "QList<QValue3DAxis*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QVALUE3DAXISPTR_IDX],
        _QList_QValue3DAxisPTR__PythonToCpp__QList_QValue3DAxisPTR_,
        is__QList_QValue3DAxisPTR__PythonToCpp__QList_QValue3DAxisPTR__Convertible);

    // Register converter for type 'QList<QSurface3DSeries*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACE3DSERIESPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSurface3DSeriesPTR__CppToPython__QList_QSurface3DSeriesPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACE3DSERIESPTR_IDX], "QList<QSurface3DSeries*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACE3DSERIESPTR_IDX],
        _QList_QSurface3DSeriesPTR__PythonToCpp__QList_QSurface3DSeriesPTR_,
        is__QList_QSurface3DSeriesPTR__PythonToCpp__QList_QSurface3DSeriesPTR__Convertible);

    // Register converter for type 'QList<QScatter3DSeries*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTER3DSERIESPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QScatter3DSeriesPTR__CppToPython__QList_QScatter3DSeriesPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTER3DSERIESPTR_IDX], "QList<QScatter3DSeries*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTER3DSERIESPTR_IDX],
        _QList_QScatter3DSeriesPTR__PythonToCpp__QList_QScatter3DSeriesPTR_,
        is__QList_QScatter3DSeriesPTR__PythonToCpp__QList_QScatter3DSeriesPTR__Convertible);

    // Register converter for type 'QList<QAbstract3DAxis*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DAXISPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QAbstract3DAxisPTR__CppToPython__QList_QAbstract3DAxisPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DAXISPTR_IDX], "QList<QAbstract3DAxis*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QABSTRACT3DAXISPTR_IDX],
        _QList_QAbstract3DAxisPTR__PythonToCpp__QList_QAbstract3DAxisPTR_,
        is__QList_QAbstract3DAxisPTR__PythonToCpp__QList_QAbstract3DAxisPTR__Convertible);

    // Register converter for type 'QList<QBar3DSeries*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBAR3DSERIESPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QBar3DSeriesPTR__CppToPython__QList_QBar3DSeriesPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBAR3DSERIESPTR_IDX], "QList<QBar3DSeries*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBAR3DSERIESPTR_IDX],
        _QList_QBar3DSeriesPTR__PythonToCpp__QList_QBar3DSeriesPTR_,
        is__QList_QBar3DSeriesPTR__PythonToCpp__QList_QBar3DSeriesPTR__Convertible);

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

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

    // Register converter for type 'QList<float>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_FLOAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_float__CppToPython__QList_float_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_FLOAT_IDX], "QList<float>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_FLOAT_IDX],
        _QList_float__PythonToCpp__QList_float_,
        is__QList_float__PythonToCpp__QList_float__Convertible);

    // Register converter for type 'QList<uchar>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UCHAR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_uchar__CppToPython__QList_uchar_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UCHAR_IDX], "QList<uchar>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UCHAR_IDX],
        _QList_uchar__PythonToCpp__QList_uchar_,
        is__QList_uchar__PythonToCpp__QList_uchar__Convertible);

    // Register converter for type 'QList<unsigned int>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UNSIGNEDINT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_unsignedint__CppToPython__QList_unsignedint_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UNSIGNEDINT_IDX], "QList<unsigned int>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_UNSIGNEDINT_IDX],
        _QList_unsignedint__PythonToCpp__QList_unsignedint_,
        is__QList_unsignedint__PythonToCpp__QList_unsignedint__Convertible);

    // Register converter for type 'QList<QImage*>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QIMAGEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QImagePTR__CppToPython__QList_QImagePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QIMAGEPTR_IDX], "QList<QImage*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QIMAGEPTR_IDX],
        _QList_QImagePTR__PythonToCpp__QList_QImagePTR_,
        is__QList_QImagePTR__PythonToCpp__QList_QImagePTR__Convertible);

    // Register converter for type 'QList<QSurfaceDataItem>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACEDATAITEM_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSurfaceDataItem__CppToPython__QList_QSurfaceDataItem_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACEDATAITEM_IDX], "QList<QSurfaceDataItem>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSURFACEDATAITEM_IDX],
        _QList_QSurfaceDataItem__PythonToCpp__QList_QSurfaceDataItem_,
        is__QList_QSurfaceDataItem__PythonToCpp__QList_QSurfaceDataItem__Convertible);

    // Register converter for type 'QList<QScatterDataItem>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTERDATAITEM_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QScatterDataItem__CppToPython__QList_QScatterDataItem_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTERDATAITEM_IDX], "QList<QScatterDataItem>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QSCATTERDATAITEM_IDX],
        _QList_QScatterDataItem__PythonToCpp__QList_QScatterDataItem_,
        is__QList_QScatterDataItem__PythonToCpp__QList_QScatterDataItem__Convertible);

    // Register converter for type 'QList<QBarDataItem>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBARDATAITEM_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QBarDataItem__CppToPython__QList_QBarDataItem_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBARDATAITEM_IDX], "QList<QBarDataItem>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QBARDATAITEM_IDX],
        _QList_QBarDataItem__PythonToCpp__QList_QBarDataItem_,
        is__QList_QBarDataItem__PythonToCpp__QList_QBarDataItem__Convertible);

    // Register converter for type 'QList<QColor>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCOLOR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QColor__CppToPython__QList_QColor_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCOLOR_IDX], "QList<QColor>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QCOLOR_IDX],
        _QList_QColor__PythonToCpp__QList_QColor_,
        is__QList_QColor__PythonToCpp__QList_QColor__Convertible);

    // Register converter for type 'QList<QLinearGradient>'.
    SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QLINEARGRADIENT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QLinearGradient__CppToPython__QList_QLinearGradient_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QLINEARGRADIENT_IDX], "QList<QLinearGradient>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtDataVisualizationTypeConverters[SBK_QTDATAVISUALIZATION_QLIST_QLINEARGRADIENT_IDX],
        _QList_QLinearGradient__PythonToCpp__QList_QLinearGradient_,
        is__QList_QLinearGradient__PythonToCpp__QList_QLinearGradient__Convertible);

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

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

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

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_QtDataVisualizationTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_QtDataVisualizationTypeConverters);

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

    FinishSignatureInitialization(module, QtDataVisualization_SignatureStrings);

    return module;
}
