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

#include <QtGui/qpixelformat.h>
#include <QtGui/qrgb.h>


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

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

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

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

        if (!PyErr_Occurred()) {
            // qAlpha(uint)
            int cppResult = qAlpha(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtGuiModule_qBlue(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qBlue";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

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

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

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

        if (!PyErr_Occurred()) {
            // qBlue(uint)
            int cppResult = qBlue(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtGuiModule_qGray(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qGray";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[3];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0};

    // invalid argument lengths
    if (numArgs == 2)
        goto SbkQtGuiModule_qGray_TypeError;

    if (!PyArg_UnpackTuple(args, "qGray", 1, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2])))
        return {};


    // Overloaded function decisor
    // 0: qGray(int,int,int)->int
    // 1: qGray(uint)->int
    if (numArgs == 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), (pyArgs[0])))) {
        overloadId = 1; // qGray(uint)
    } else if (numArgs == 3
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))) {
        overloadId = 0; // qGray(int,int,int)
    }

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

    // Call function/method
    switch (overloadId) {
        case 0: // qGray(int r, int g, int b)
        {
            int cppArg0;
            pythonToCpp[0](pyArgs[0], &cppArg0);
            int cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);

            if (!PyErr_Occurred()) {
                // qGray(int,int,int)
                int cppResult = qGray(cppArg0, cppArg1, cppArg2);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            }
            break;
        }
        case 1: // qGray(unsigned int rgb)
        {
            unsigned int cppArg0;
            pythonToCpp[0](pyArgs[0], &cppArg0);

            if (!PyErr_Occurred()) {
                // qGray(uint)
                int cppResult = qGray(cppArg0);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            }
            break;
        }
    }

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

    SbkQtGuiModule_qGray_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qGreen(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qGreen";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

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

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

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

        if (!PyErr_Occurred()) {
            // qGreen(uint)
            int cppResult = qGreen(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtGuiModule_qIsGray(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qIsGray";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

    // Overloaded function decisor
    // 0: qIsGray(uint)->bool
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), (pyArg)))) {
        overloadId = 0; // qIsGray(uint)
    }

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

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

        if (!PyErr_Occurred()) {
            // qIsGray(uint)
            bool cppResult = qIsGray(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtGuiModule_qPixelFormatAlpha(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatAlpha";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0};

    // invalid argument lengths
    if (numArgs > 2) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatAlpha_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatAlpha_TypeError;
    }

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


    // Overloaded function decisor
    // 0: qPixelFormatAlpha(uchar,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 1
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatAlpha(uchar,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 2
            && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[1])))) {
            overloadId = 0; // qPixelFormatAlpha(uchar,QPixelFormat::TypeInterpretation)
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatAlpha_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!(pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatAlpha_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatAlpha_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        ::QPixelFormat::TypeInterpretation cppArg1(QPixelFormat::UnsignedInteger);
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);

        if (!PyErr_Occurred()) {
            // qPixelFormatAlpha(uchar,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatAlpha(cppArg0, cppArg1);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatAlpha_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatCmyk(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatCmyk";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[5];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0, 0};

    // invalid argument lengths
    if (numArgs > 5) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
    }

    if (!PyArg_ParseTuple(args, "|OOOOO:qPixelFormatCmyk", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4])))
        return {};


    // Overloaded function decisor
    // 0: qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 1
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 2
            && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1])))) {
            if (numArgs == 2) {
                overloadId = 0; // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            } else if (numArgs >= 3
                && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2])))) {
                if (numArgs == 3) {
                    overloadId = 0; // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                } else if (numArgs >= 4
                    && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3])))) {
                    if (numArgs == 4) {
                        overloadId = 0; // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    } else if (numArgs >= 5
                        && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4])))) {
                        overloadId = 0; // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    }
                }
            }
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_alfa = Shiboken::String::createStaticString("alfa");
            if (PyDict_Contains(kwds, key_alfa)) {
                value = PyDict_GetItem(kwds, key_alfa);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_alfa);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_alfa);
            }
            static PyObject *const key_usage = Shiboken::String::createStaticString("usage");
            if (PyDict_Contains(kwds, key_usage)) {
                value = PyDict_GetItem(kwds, key_usage);
                if (value && pyArgs[2]) {
                    errInfo.reset(key_usage);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                if (value) {
                    pyArgs[2] = value;
                    if (!(pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2]))))
                        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_usage);
            }
            static PyObject *const key_position = Shiboken::String::createStaticString("position");
            if (PyDict_Contains(kwds, key_position)) {
                value = PyDict_GetItem(kwds, key_position);
                if (value && pyArgs[3]) {
                    errInfo.reset(key_position);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                if (value) {
                    pyArgs[3] = value;
                    if (!(pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3]))))
                        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_position);
            }
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[4]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                if (value) {
                    pyArgs[4] = value;
                    if (!(pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4]))))
                        goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatCmyk_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        uchar cppArg1 = 0;
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);
        ::QPixelFormat::AlphaUsage cppArg2(QPixelFormat::IgnoresAlpha);
        if (pythonToCpp[2])
            pythonToCpp[2](pyArgs[2], &cppArg2);
        ::QPixelFormat::AlphaPosition cppArg3(QPixelFormat::AtBeginning);
        if (pythonToCpp[3])
            pythonToCpp[3](pyArgs[3], &cppArg3);
        ::QPixelFormat::TypeInterpretation cppArg4(QPixelFormat::UnsignedInteger);
        if (pythonToCpp[4])
            pythonToCpp[4](pyArgs[4], &cppArg4);

        if (!PyErr_Occurred()) {
            // qPixelFormatCmyk(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatCmyk(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatCmyk_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatGrayscale(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatGrayscale";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0};

    // invalid argument lengths
    if (numArgs > 2) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatGrayscale_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatGrayscale_TypeError;
    }

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


    // Overloaded function decisor
    // 0: qPixelFormatGrayscale(uchar,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 1
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatGrayscale(uchar,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 2
            && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[1])))) {
            overloadId = 0; // qPixelFormatGrayscale(uchar,QPixelFormat::TypeInterpretation)
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatGrayscale_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!(pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatGrayscale_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatGrayscale_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        ::QPixelFormat::TypeInterpretation cppArg1(QPixelFormat::UnsignedInteger);
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);

        if (!PyErr_Occurred()) {
            // qPixelFormatGrayscale(uchar,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatGrayscale(cppArg0, cppArg1);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatGrayscale_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatHsl(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatHsl";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[5];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0, 0};

    // invalid argument lengths
    if (numArgs > 5) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
    }

    if (!PyArg_ParseTuple(args, "|OOOOO:qPixelFormatHsl", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4])))
        return {};


    // Overloaded function decisor
    // 0: qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 1
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 2
            && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1])))) {
            if (numArgs == 2) {
                overloadId = 0; // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            } else if (numArgs >= 3
                && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2])))) {
                if (numArgs == 3) {
                    overloadId = 0; // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                } else if (numArgs >= 4
                    && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3])))) {
                    if (numArgs == 4) {
                        overloadId = 0; // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    } else if (numArgs >= 5
                        && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4])))) {
                        overloadId = 0; // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    }
                }
            }
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_alfa = Shiboken::String::createStaticString("alfa");
            if (PyDict_Contains(kwds, key_alfa)) {
                value = PyDict_GetItem(kwds, key_alfa);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_alfa);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_alfa);
            }
            static PyObject *const key_usage = Shiboken::String::createStaticString("usage");
            if (PyDict_Contains(kwds, key_usage)) {
                value = PyDict_GetItem(kwds, key_usage);
                if (value && pyArgs[2]) {
                    errInfo.reset(key_usage);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                if (value) {
                    pyArgs[2] = value;
                    if (!(pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2]))))
                        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_usage);
            }
            static PyObject *const key_position = Shiboken::String::createStaticString("position");
            if (PyDict_Contains(kwds, key_position)) {
                value = PyDict_GetItem(kwds, key_position);
                if (value && pyArgs[3]) {
                    errInfo.reset(key_position);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                if (value) {
                    pyArgs[3] = value;
                    if (!(pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3]))))
                        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_position);
            }
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[4]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                if (value) {
                    pyArgs[4] = value;
                    if (!(pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4]))))
                        goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatHsl_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        uchar cppArg1 = 0;
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);
        ::QPixelFormat::AlphaUsage cppArg2(QPixelFormat::IgnoresAlpha);
        if (pythonToCpp[2])
            pythonToCpp[2](pyArgs[2], &cppArg2);
        ::QPixelFormat::AlphaPosition cppArg3(QPixelFormat::AtBeginning);
        if (pythonToCpp[3])
            pythonToCpp[3](pyArgs[3], &cppArg3);
        ::QPixelFormat::TypeInterpretation cppArg4(QPixelFormat::FloatingPoint);
        if (pythonToCpp[4])
            pythonToCpp[4](pyArgs[4], &cppArg4);

        if (!PyErr_Occurred()) {
            // qPixelFormatHsl(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatHsl(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatHsl_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatHsv(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatHsv";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[5];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0, 0};

    // invalid argument lengths
    if (numArgs > 5) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
    }

    if (!PyArg_ParseTuple(args, "|OOOOO:qPixelFormatHsv", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4])))
        return {};


    // Overloaded function decisor
    // 0: qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 1
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 2
            && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1])))) {
            if (numArgs == 2) {
                overloadId = 0; // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            } else if (numArgs >= 3
                && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2])))) {
                if (numArgs == 3) {
                    overloadId = 0; // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                } else if (numArgs >= 4
                    && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3])))) {
                    if (numArgs == 4) {
                        overloadId = 0; // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    } else if (numArgs >= 5
                        && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4])))) {
                        overloadId = 0; // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
                    }
                }
            }
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_alfa = Shiboken::String::createStaticString("alfa");
            if (PyDict_Contains(kwds, key_alfa)) {
                value = PyDict_GetItem(kwds, key_alfa);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_alfa);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_alfa);
            }
            static PyObject *const key_usage = Shiboken::String::createStaticString("usage");
            if (PyDict_Contains(kwds, key_usage)) {
                value = PyDict_GetItem(kwds, key_usage);
                if (value && pyArgs[2]) {
                    errInfo.reset(key_usage);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                if (value) {
                    pyArgs[2] = value;
                    if (!(pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2]))))
                        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_usage);
            }
            static PyObject *const key_position = Shiboken::String::createStaticString("position");
            if (PyDict_Contains(kwds, key_position)) {
                value = PyDict_GetItem(kwds, key_position);
                if (value && pyArgs[3]) {
                    errInfo.reset(key_position);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                if (value) {
                    pyArgs[3] = value;
                    if (!(pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3]))))
                        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_position);
            }
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[4]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                if (value) {
                    pyArgs[4] = value;
                    if (!(pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[4]))))
                        goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatHsv_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        uchar cppArg1 = 0;
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);
        ::QPixelFormat::AlphaUsage cppArg2(QPixelFormat::IgnoresAlpha);
        if (pythonToCpp[2])
            pythonToCpp[2](pyArgs[2], &cppArg2);
        ::QPixelFormat::AlphaPosition cppArg3(QPixelFormat::AtBeginning);
        if (pythonToCpp[3])
            pythonToCpp[3](pyArgs[3], &cppArg3);
        ::QPixelFormat::TypeInterpretation cppArg4(QPixelFormat::FloatingPoint);
        if (pythonToCpp[4])
            pythonToCpp[4](pyArgs[4], &cppArg4);

        if (!PyErr_Occurred()) {
            // qPixelFormatHsv(uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatHsv(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatHsv_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatRgba(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatRgba";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[8];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0, 0, 0, 0, 0};

    // invalid argument lengths
    if (numArgs > 8) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
    } else if (numArgs < 6) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
    }

    if (!PyArg_ParseTuple(args, "|OOOOOOOO:qPixelFormatRgba", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4]), &(pyArgs[5]), &(pyArgs[6]), &(pyArgs[7])))
        return {};


    // Overloaded function decisor
    // 0: qPixelFormatRgba(uchar,uchar,uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation)->QPixelFormat
    if (numArgs >= 6
        && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[0])))
        && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1])))
        && SbkChar_Check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[2])))
        && SbkChar_Check(pyArgs[3]) && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[3])))
        && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[4])))
        && (pythonToCpp[5] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[5])))) {
        if (numArgs == 6) {
            overloadId = 0; // qPixelFormatRgba(uchar,uchar,uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation)
        } else if (numArgs >= 7
            && (pythonToCpp[6] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPREMULTIPLIED_IDX]))->converter, (pyArgs[6])))) {
            if (numArgs == 7) {
                overloadId = 0; // qPixelFormatRgba(uchar,uchar,uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation)
            } else if (numArgs >= 8
                && (pythonToCpp[7] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[7])))) {
                overloadId = 0; // qPixelFormatRgba(uchar,uchar,uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation)
            }
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_pmul = Shiboken::String::createStaticString("pmul");
            if (PyDict_Contains(kwds, key_pmul)) {
                value = PyDict_GetItem(kwds, key_pmul);
                if (value && pyArgs[6]) {
                    errInfo.reset(key_pmul);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
                }
                if (value) {
                    pyArgs[6] = value;
                    if (!(pythonToCpp[6] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPREMULTIPLIED_IDX]))->converter, (pyArgs[6]))))
                        goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_pmul);
            }
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[7]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
                }
                if (value) {
                    pyArgs[7] = value;
                    if (!(pythonToCpp[7] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[7]))))
                        goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatRgba_TypeError;
            }
        }
        uchar cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        uchar cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        uchar cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        uchar cppArg3;
        pythonToCpp[3](pyArgs[3], &cppArg3);
        ::QPixelFormat::AlphaUsage cppArg4{QPixelFormat::UsesAlpha};
        pythonToCpp[4](pyArgs[4], &cppArg4);
        ::QPixelFormat::AlphaPosition cppArg5{QPixelFormat::AtBeginning};
        pythonToCpp[5](pyArgs[5], &cppArg5);
        ::QPixelFormat::AlphaPremultiplied cppArg6(QPixelFormat::NotPremultiplied);
        if (pythonToCpp[6])
            pythonToCpp[6](pyArgs[6], &cppArg6);
        ::QPixelFormat::TypeInterpretation cppArg7(QPixelFormat::UnsignedInteger);
        if (pythonToCpp[7])
            pythonToCpp[7](pyArgs[7], &cppArg7);

        if (!PyErr_Occurred()) {
            // qPixelFormatRgba(uchar,uchar,uchar,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation)
            QPixelFormat cppResult = qPixelFormatRgba(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4, cppArg5, cppArg6, cppArg7);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatRgba_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qPixelFormatYuv(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qPixelFormatYuv";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[7];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0, 0, 0, 0};

    // invalid argument lengths
    if (numArgs > 7) {
        static PyObject *const too_many = Shiboken::String::createStaticString(">");
        errInfo.reset(too_many);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
    } else if (numArgs < 1) {
        static PyObject *const too_few = Shiboken::String::createStaticString("<");
        errInfo.reset(too_few);
        Py_INCREF(errInfo.object());
        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
    }

    if (!PyArg_ParseTuple(args, "|OOOOOOO:qPixelFormatYuv", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4]), &(pyArgs[5]), &(pyArgs[6])))
        return {};


    // Overloaded function decisor
    // 0: qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)->QPixelFormat
    if (numArgs >= 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_YUVLAYOUT_IDX]))->converter, (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
        } else if (numArgs >= 2
            && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1])))) {
            if (numArgs == 2) {
                overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
            } else if (numArgs >= 3
                && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2])))) {
                if (numArgs == 3) {
                    overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
                } else if (numArgs >= 4
                    && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3])))) {
                    if (numArgs == 4) {
                        overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
                    } else if (numArgs >= 5
                        && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPREMULTIPLIED_IDX]))->converter, (pyArgs[4])))) {
                        if (numArgs == 5) {
                            overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
                        } else if (numArgs >= 6
                            && (pythonToCpp[5] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[5])))) {
                            if (numArgs == 6) {
                                overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
                            } else if (numArgs >= 7
                                && (pythonToCpp[6] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_BYTEORDER_IDX]))->converter, (pyArgs[6])))) {
                                overloadId = 0; // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
                            }
                        }
                    }
                }
            }
        }
    }

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

    // Call function/method
    {
        if (kwds && PyDict_Size(kwds) > 0) {
            PyObject *value{};
            Shiboken::AutoDecRef kwds_dup(PyDict_Copy(kwds));
            static PyObject *const key_alfa = Shiboken::String::createStaticString("alfa");
            if (PyDict_Contains(kwds, key_alfa)) {
                value = PyDict_GetItem(kwds, key_alfa);
                if (value && pyArgs[1]) {
                    errInfo.reset(key_alfa);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[1] = value;
                    if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<uchar>(), (pyArgs[1]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_alfa);
            }
            static PyObject *const key_usage = Shiboken::String::createStaticString("usage");
            if (PyDict_Contains(kwds, key_usage)) {
                value = PyDict_GetItem(kwds, key_usage);
                if (value && pyArgs[2]) {
                    errInfo.reset(key_usage);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[2] = value;
                    if (!(pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAUSAGE_IDX]))->converter, (pyArgs[2]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_usage);
            }
            static PyObject *const key_position = Shiboken::String::createStaticString("position");
            if (PyDict_Contains(kwds, key_position)) {
                value = PyDict_GetItem(kwds, key_position);
                if (value && pyArgs[3]) {
                    errInfo.reset(key_position);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[3] = value;
                    if (!(pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPOSITION_IDX]))->converter, (pyArgs[3]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_position);
            }
            static PyObject *const key_p_mul = Shiboken::String::createStaticString("p_mul");
            if (PyDict_Contains(kwds, key_p_mul)) {
                value = PyDict_GetItem(kwds, key_p_mul);
                if (value && pyArgs[4]) {
                    errInfo.reset(key_p_mul);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[4] = value;
                    if (!(pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_ALPHAPREMULTIPLIED_IDX]))->converter, (pyArgs[4]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_p_mul);
            }
            static PyObject *const key_typeInt = Shiboken::String::createStaticString("typeInt");
            if (PyDict_Contains(kwds, key_typeInt)) {
                value = PyDict_GetItem(kwds, key_typeInt);
                if (value && pyArgs[5]) {
                    errInfo.reset(key_typeInt);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[5] = value;
                    if (!(pythonToCpp[5] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_TYPEINTERPRETATION_IDX]))->converter, (pyArgs[5]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_typeInt);
            }
            static PyObject *const key_b_order = Shiboken::String::createStaticString("b_order");
            if (PyDict_Contains(kwds, key_b_order)) {
                value = PyDict_GetItem(kwds, key_b_order);
                if (value && pyArgs[6]) {
                    errInfo.reset(key_b_order);
                    Py_INCREF(errInfo.object());
                    goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                if (value) {
                    pyArgs[6] = value;
                    if (!(pythonToCpp[6] = Shiboken::Conversions::pythonToCppConversion(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_BYTEORDER_IDX]))->converter, (pyArgs[6]))))
                        goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
                }
                PyDict_DelItem(kwds_dup, key_b_order);
            }
            if (PyDict_Size(kwds_dup) > 0) {
                errInfo.reset(kwds_dup.release());
                goto SbkQtGuiModule_qPixelFormatYuv_TypeError;
            }
        }
        ::QPixelFormat::YUVLayout cppArg0{QPixelFormat::YUV444};
        pythonToCpp[0](pyArgs[0], &cppArg0);
        uchar cppArg1 = 0;
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);
        ::QPixelFormat::AlphaUsage cppArg2(QPixelFormat::IgnoresAlpha);
        if (pythonToCpp[2])
            pythonToCpp[2](pyArgs[2], &cppArg2);
        ::QPixelFormat::AlphaPosition cppArg3(QPixelFormat::AtBeginning);
        if (pythonToCpp[3])
            pythonToCpp[3](pyArgs[3], &cppArg3);
        ::QPixelFormat::AlphaPremultiplied cppArg4(QPixelFormat::NotPremultiplied);
        if (pythonToCpp[4])
            pythonToCpp[4](pyArgs[4], &cppArg4);
        ::QPixelFormat::TypeInterpretation cppArg5(QPixelFormat::UnsignedByte);
        if (pythonToCpp[5])
            pythonToCpp[5](pyArgs[5], &cppArg5);
        ::QPixelFormat::ByteOrder cppArg6(QPixelFormat::LittleEndian);
        if (pythonToCpp[6])
            pythonToCpp[6](pyArgs[6], &cppArg6);

        if (!PyErr_Occurred()) {
            // qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)
            QPixelFormat cppResult = qPixelFormatYuv(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4, cppArg5, cppArg6);
            pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QPIXELFORMAT_IDX], &cppResult);
        }
    }

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

    SbkQtGuiModule_qPixelFormatYuv_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qRed(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qRed";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

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

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

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

        if (!PyErr_Occurred()) {
            // qRed(uint)
            int cppResult = qRed(cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtGuiModule_qRgb(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qRgb";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[3];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0};

    // invalid argument lengths


    if (!PyArg_UnpackTuple(args, "qRgb", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2])))
        return {};


    // Overloaded function decisor
    // 0: qRgb(int,int,int)->unsigned int
    if (numArgs == 3
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))) {
        overloadId = 0; // qRgb(int,int,int)
    }

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

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

        if (!PyErr_Occurred()) {
            // qRgb(int,int,int)
            unsigned int cppResult = qRgb(cppArg0, cppArg1, cppArg2);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), &cppResult);
        }
    }

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

    SbkQtGuiModule_qRgb_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}

static PyObject *SbkQtGuiModule_qRgba(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtGui.qRgba";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp[4];
    SBK_UNUSED(pythonToCpp)
    const Py_ssize_t numArgs = PyTuple_GET_SIZE(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {0, 0, 0, 0};

    // invalid argument lengths


    if (!PyArg_UnpackTuple(args, "qRgba", 4, 4, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3])))
        return {};


    // Overloaded function decisor
    // 0: qRgba(int,int,int,int)->unsigned int
    if (numArgs == 4
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))) {
        overloadId = 0; // qRgba(int,int,int,int)
    }

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

    // Call function/method
    {
        int cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        int cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        int cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        int cppArg3;
        pythonToCpp[3](pyArgs[3], &cppArg3);

        if (!PyErr_Occurred()) {
            // qRgba(int,int,int,int)
            unsigned int cppResult = qRgba(cppArg0, cppArg1, cppArg2, cppArg3);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), &cppResult);
        }
    }

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

    SbkQtGuiModule_qRgba_TypeError:
        Shiboken::setErrorAboutWrongArguments(args, fullName, errInfo);
        return {};
}


static PyMethodDef QtGui_methods[] = {
    {"qAlpha", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qAlpha), METH_O},
    {"qBlue", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qBlue), METH_O},
    {"qGray", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qGray), METH_VARARGS},
    {"qGreen", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qGreen), METH_O},
    {"qIsGray", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qIsGray), METH_O},
    {"qPixelFormatAlpha", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatAlpha), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatCmyk", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatCmyk), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatGrayscale", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatGrayscale), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatHsl", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatHsl), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatHsv", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatHsv), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatRgba", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatRgba), METH_VARARGS|METH_KEYWORDS},
    {"qPixelFormatYuv", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qPixelFormatYuv), METH_VARARGS|METH_KEYWORDS},
    {"qRed", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qRed), METH_O},
    {"qRgb", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qRgb), METH_VARARGS},
    {"qRgba", reinterpret_cast<PyCFunction>(SbkQtGuiModule_qRgba), METH_VARARGS},
    {0} // Sentinel
};

// Classes initialization functions ------------------------------------------------------------
void init_QtGuiQt(PyObject *module);
void init_QVector4D(PyObject *module);
void init_QVector3D(PyObject *module);
void init_QVector2D(PyObject *module);
void init_QUndoCommand(PyObject *module);
void init_QTransform(PyObject *module);
void init_QTextTableCell(PyObject *module);
void init_QTextOption(PyObject *module);
void init_QTextOption_Tab(PyObject *enclosingClass);
void init_QTextObjectInterface(PyObject *module);
void init_QTextLine(PyObject *module);
void init_QTextLength(PyObject *module);
void init_QTextItem(PyObject *module);
void init_QTextInlineObject(PyObject *module);
void init_QTextFragment(PyObject *module);
void init_QTextFormat(PyObject *module);
void init_QTextListFormat(PyObject *module);
void init_QTextFrameFormat(PyObject *module);
void init_QTextTableFormat(PyObject *module);
void init_QTextDocumentFragment(PyObject *module);
void init_QTextCursor(PyObject *module);
void init_QTextCharFormat(PyObject *module);
void init_QTextTableCellFormat(PyObject *module);
void init_QTextImageFormat(PyObject *module);
void init_QTextBlockUserData(PyObject *module);
void init_QTextBlockFormat(PyObject *module);
void init_QTextBlock(PyObject *module);
void init_QTextBlock_iterator(PyObject *enclosingClass);
void init_QSurfaceFormat(PyObject *module);
void init_QSurface(PyObject *module);
void init_QStandardItem(PyObject *module);
void init_QRgba64(PyObject *module);
void init_QRegion(PyObject *module);
void init_QRawFont(PyObject *module);
void init_QQuaternion(PyObject *module);
void init_QPolygonF(PyObject *module);
void init_QPolygon(PyObject *module);
void init_QPointingDeviceUniqueId(PyObject *module);
void init_QPixmapCache(PyObject *module);
void init_QPixmapCache_Key(PyObject *enclosingClass);
void init_QPixelFormat(PyObject *module);
void init_QPen(PyObject *module);
void init_QPalette(PyObject *module);
void init_QPainterPathStroker(PyObject *module);
void init_QPainterPath(PyObject *module);
void init_QPainterPath_Element(PyObject *enclosingClass);
void init_QPaintEngineState(PyObject *module);
void init_QPaintEngine(PyObject *module);
void init_QPaintDevice(PyObject *module);
void init_QPicture(PyObject *module);
void init_QPagedPaintDevice(PyObject *module);
void init_QPageSize(PyObject *module);
void init_QPageRanges(PyObject *module);
void init_QPageRanges_Range(PyObject *enclosingClass);
void init_QOpenGLFunctions(PyObject *module);
void init_QOpenGLExtraFunctions(PyObject *module);
void init_QMatrix4x4(PyObject *module);
void init_QMatrix4x3(PyObject *module);
void init_QMatrix4x2(PyObject *module);
void init_QMatrix3x4(PyObject *module);
void init_QMatrix3x3(PyObject *module);
void init_QMatrix3x2(PyObject *module);
void init_QMatrix2x4(PyObject *module);
void init_QMatrix2x3(PyObject *module);
void init_QMatrix2x2(PyObject *module);
void init_QImageIOHandler(PyObject *module);
void init_QIconEngine(PyObject *module);
void init_QGradient(PyObject *module);
void init_QRadialGradient(PyObject *module);
void init_QLinearGradient(PyObject *module);
void init_QGlyphRun(PyObject *module);
void init_QFontMetricsF(PyObject *module);
void init_QFontMetrics(PyObject *module);
void init_QFontInfo(PyObject *module);
void init_QFontDatabase(PyObject *module);
void init_QFont(PyObject *module);
void init_QStaticText(PyObject *module);
void init_QEventPoint(PyObject *module);
void init_QDesktopServices(PyObject *module);
void init_QCursor(PyObject *module);
void init_QConicalGradient(PyObject *module);
void init_QColorTransform(PyObject *module);
void init_QColorSpace(PyObject *module);
void init_QColor(PyObject *module);
void init_QtGuiQColorConstants(PyObject *module);
void init_QtGuiQColorConstantsStaticFields();
void init_QtGuiQColorConstants_Svg(PyObject *enclosingClass);
void init_QtGuiQColorConstants_SvgStaticFields();
void init_QBrush(PyObject *module);
void init_QAccessibleValueInterface(PyObject *module);
void init_QAccessibleTextInterface(PyObject *module);
void init_QAccessibleTableCellInterface(PyObject *module);
void init_QAccessibleInterface(PyObject *module);
void init_QAccessibleObject(PyObject *module);
void init_QAccessibleEvent(PyObject *module);
void init_QAccessibleValueChangeEvent(PyObject *module);
void init_QAccessibleTextCursorEvent(PyObject *module);
void init_QAccessibleTextUpdateEvent(PyObject *module);
void init_QAccessibleTextSelectionEvent(PyObject *module);
void init_QAccessibleTextRemoveEvent(PyObject *module);
void init_QAccessibleTextInsertEvent(PyObject *module);
void init_QAccessibleTableModelChangeEvent(PyObject *module);
void init_QAccessibleStateChangeEvent(PyObject *module);
void init_QAccessibleEditableTextInterface(PyObject *module);
void init_QAccessibleActionInterface(PyObject *module);
void init_QAccessible(PyObject *module);
void init_QAccessible_State(PyObject *enclosingClass);
void init_QAbstractFileIconProvider(PyObject *module);
void init_QIcon(PyObject *module);
void init_QTextLayout(PyObject *module);
void init_QTextLayout_FormatRange(PyObject *enclosingClass);
void init_QPixmap(PyObject *module);
void init_QIconEngine_ScaledPixmapArgument(PyObject *enclosingClass);
void init_QImage(PyObject *module);
void init_QBitmap(PyObject *module);
void init_QPainter(PyObject *module);
void init_QPainter_PixmapFragment(PyObject *enclosingClass);
void init_QBackingStore(PyObject *module);
void init_QPageLayout(PyObject *module);
void init_QKeySequence(PyObject *module);
void init_QWindow(PyObject *module);
void init_QPaintDeviceWindow(PyObject *module);
void init_QRasterWindow(PyObject *module);
void init_QValidator(PyObject *module);
void init_QRegularExpressionValidator(PyObject *module);
void init_QIntValidator(PyObject *module);
void init_QDoubleValidator(PyObject *module);
void init_QUndoStack(PyObject *module);
void init_QUndoGroup(PyObject *module);
void init_QTextObject(PyObject *module);
void init_QTextFrame(PyObject *module);
void init_QTextTable(PyObject *module);
void init_QTextFrame_iterator(PyObject *enclosingClass);
void init_QTextBlockGroup(PyObject *module);
void init_QTextList(PyObject *module);
void init_QTextDocument(PyObject *module);
void init_QSyntaxHighlighter(PyObject *module);
void init_QStyleHints(PyObject *module);
void init_QShortcut(PyObject *module);
void init_QSessionManager(PyObject *module);
void init_QScreen(PyObject *module);
void init_QPyTextObject(PyObject *module);
void init_QPdfWriter(PyObject *module);
void init_QOpenGLContextGroup(PyObject *module);
void init_QOpenGLContext(PyObject *module);
void init_QOffscreenSurface(PyObject *module);
void init_QInputMethod(PyObject *module);
void init_QInputDevice(PyObject *module);
void init_QPointingDevice(PyObject *module);
void init_QDrag(PyObject *module);
void init_QClipboard(PyObject *module);
void init_QActionGroup(PyObject *module);
void init_QAction(PyObject *module);
void init_QAbstractTextDocumentLayout(PyObject *module);
void init_QAbstractTextDocumentLayout_Selection(PyObject *enclosingClass);
void init_QAbstractTextDocumentLayout_PaintContext(PyObject *enclosingClass);
void init_QWindowStateChangeEvent(PyObject *module);
void init_QWhatsThisClickedEvent(PyObject *module);
void init_QToolBarChangeEvent(PyObject *module);
void init_QStatusTipEvent(PyObject *module);
void init_QShowEvent(PyObject *module);
void init_QShortcutEvent(PyObject *module);
void init_QScrollPrepareEvent(PyObject *module);
void init_QScrollEvent(PyObject *module);
void init_QResizeEvent(PyObject *module);
void init_QPlatformSurfaceEvent(PyObject *module);
void init_QPaintEvent(PyObject *module);
void init_QMoveEvent(PyObject *module);
void init_QInputMethodQueryEvent(PyObject *module);
void init_QInputMethodEvent(PyObject *module);
void init_QInputMethodEvent_Attribute(PyObject *enclosingClass);
void init_QInputEvent(PyObject *module);
void init_QPointerEvent(PyObject *module);
void init_QTouchEvent(PyObject *module);
void init_QSinglePointEvent(PyObject *module);
void init_QWheelEvent(PyObject *module);
void init_QTabletEvent(PyObject *module);
void init_QNativeGestureEvent(PyObject *module);
void init_QMouseEvent(PyObject *module);
void init_QHoverEvent(PyObject *module);
void init_QEnterEvent(PyObject *module);
void init_QKeyEvent(PyObject *module);
void init_QContextMenuEvent(PyObject *module);
void init_QIconDragEvent(PyObject *module);
void init_QHideEvent(PyObject *module);
void init_QHelpEvent(PyObject *module);
void init_QFocusEvent(PyObject *module);
void init_QFileOpenEvent(PyObject *module);
void init_QExposeEvent(PyObject *module);
void init_QDropEvent(PyObject *module);
void init_QDragMoveEvent(PyObject *module);
void init_QDragEnterEvent(PyObject *module);
void init_QDragLeaveEvent(PyObject *module);
void init_QCloseEvent(PyObject *module);
void init_QActionEvent(PyObject *module);
void init_QGuiApplication(PyObject *module);
void init_QTextDocumentWriter(PyObject *module);
void init_QMovie(PyObject *module);
void init_QImageWriter(PyObject *module);
void init_QImageReader(PyObject *module);
void init_QStandardItemModel(PyObject *module);

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

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

// Extended Converters.

// Extended implicit conversions for PySide6.QtCore.QPointF.
static void QPainterPath_Element_PythonToCpp_PySide6_QtCore_QPointF(PyObject *pyIn, void *cppOut)
{
    *reinterpret_cast<::QPointF *>(cppOut) = ::QPointF(*reinterpret_cast< ::QPainterPath::Element *>(Shiboken::Conversions::cppPointer(SbkPySide6_QtGuiTypes[SBK_QPAINTERPATH_ELEMENT_IDX], reinterpret_cast<SbkObject *>(pyIn))));
}
static PythonToCppFunc is_QPainterPath_Element_PythonToCpp_PySide6_QtCore_QPointF_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, SbkPySide6_QtGuiTypes[SBK_QPAINTERPATH_ELEMENT_IDX]))
        return QPainterPath_Element_PythonToCpp_PySide6_QtCore_QPointF;
    return {};
}


// Primitive Type converters.

// C++ to Python conversion for primitive type 'WId'.
static PyObject *WId_CppToPython_WId(const void *cppIn)
{
    auto &cppInRef = *reinterpret_cast<::WId *>(const_cast<void *>(cppIn));
    // ========================================================================
    // START of custom code block [file: ../glue/qtgui.cpp (return-pylong-voidptr)]
    return PyLong_FromVoidPtr(reinterpret_cast<void *>(cppInRef));
    // END of custom code block [file: ../glue/qtgui.cpp (return-pylong-voidptr)]
    // ========================================================================

}
// Python to C++ conversions for type 'WId'.
static void PyLong_PythonToCpp_WId(PyObject *pyIn, void *cppOut)
{
    // ========================================================================
    // START of custom code block [file: ../glue/qtgui.cpp (conversion-pylong)]
    *reinterpret_cast<::WId *>(cppOut) = reinterpret_cast<WId>(PyLong_AsVoidPtr(pyIn));
    // END of custom code block [file: ../glue/qtgui.cpp (conversion-pylong)]
    // ========================================================================

}
static PythonToCppFunc is_PyLong_PythonToCpp_WId_Convertible(PyObject *pyIn)
{
    if (PyLong_Check(pyIn))
        return PyLong_PythonToCpp_WId;
    return {};
}


// Container Type converters.

// 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<QTextOption::Tab >'.
static PyObject *_QList_QTextOption_Tab__CppToPython__QList_QTextOption_Tab_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QTextOption::Tab > *>(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_QTEXTOPTION_TAB_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QTextOption_Tab__PythonToCpp__QList_QTextOption_Tab__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTOPTION_TAB_IDX], pyIn))
        return _QList_QTextOption_Tab__PythonToCpp__QList_QTextOption_Tab_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QGlyphRun__PythonToCpp__QList_QGlyphRun__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QGLYPHRUN_IDX], pyIn))
        return _QList_QGlyphRun__PythonToCpp__QList_QGlyphRun_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QTextLength__PythonToCpp__QList_QTextLength__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTLENGTH_IDX], pyIn))
        return _QList_QTextLength__PythonToCpp__QList_QTextLength_;
    return {};
}

// C++ to Python conversion for container type 'QMap<int,QVariant >'.
static PyObject *_QMap_int_QVariant__CppToPython__QMap_int_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<int,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(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - cppmap_to_pymap_conversion - END

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

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

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

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

}
static PythonToCppFunc is__QList_QTextLayout_FormatRange__PythonToCpp__QList_QTextLayout_FormatRange__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTLAYOUT_FORMATRANGE_IDX], pyIn))
        return _QList_QTextLayout_FormatRange__PythonToCpp__QList_QTextLayout_FormatRange_;
    return {};
}

// C++ to Python conversion for container type 'QPair<int,int >'.
static PyObject *_QPair_int_int__CppToPython__QPair_int_int_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QPair<int,int > *>(cppIn);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    PyObject *pyOut = PyTuple_New(2);
    PyTuple_SET_ITEM(pyOut, 0, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppInRef.first));
    PyTuple_SET_ITEM(pyOut, 1, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppInRef.second));
    return pyOut;
    // END of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    // ========================================================================

}
static void _QPair_int_int__PythonToCpp__QPair_int_int_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QPair<int,int > *>(cppOut);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<int>(), PySequence_Fast_GET_ITEM(pyIn, 0), &(cppOutRef.first));
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<int>(), PySequence_Fast_GET_ITEM(pyIn, 1), &(cppOutRef.second));
    // END of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    // ========================================================================

}
static PythonToCppFunc is__QPair_int_int__PythonToCpp__QPair_int_int__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertiblePairTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, pyIn))
        return _QPair_int_int__PythonToCpp__QPair_int_int_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QStandardItemPTR__PythonToCpp__QList_QStandardItemPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QSTANDARDITEM_IDX], pyIn))
        return _QList_QStandardItemPTR__PythonToCpp__QList_QStandardItemPTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QPointF__PythonToCpp__QList_QPointF__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QPOINTF_IDX], pyIn))
        return _QList_QPointF__PythonToCpp__QList_QPointF_;
    return {};
}


// Binding for QList<QPointF >

template <>
struct ShibokenContainerValueConverter<QPointF>
{
    static bool checkValue(PyObject *pyArg)
    {
        return SbkObject_TypeCheck(SbkPySide6_QtCoreTypes[SBK_QPOINTF_IDX], pyArg);
    }

    static PyObject *convertValueToPython(const QPointF &cppArg)
    {
        return Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypes[SBK_QPOINTF_IDX], &cppArg);
    }

    static std::optional<QPointF> convertValueToCpp(PyObject *pyArg)
    {
        Shiboken::Conversions::PythonToCppConversion pythonToCpp;
        if (!((pythonToCpp = Shiboken::Conversions::pythonToCppValueConversion(SbkPySide6_QtCoreTypes[SBK_QPOINTF_IDX], (pyArg))))) {
            PyErr_SetString(PyExc_TypeError, "Wrong type passed to container conversion.");
            return {};
        }
        ::QPointF cppArg;
        pythonToCpp(pyArg, &cppArg);
        return cppArg;
    }
};

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

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

static PyType_Spec QPointFList_spec = {
    "1:QtGui.QPointFList",
    sizeof(ShibokenContainer),
    0,
    Py_TPFLAGS_DEFAULT,
    QPointFList_slots
};

static inline PyTypeObject *createQPointFListType()
{
    auto *result = reinterpret_cast<PyTypeObject *>(SbkType_FromSpec(&QPointFList_spec));
    Py_INCREF(Py_True);
    PyDict_SetItem(result->tp_dict, Shiboken::PyMagicName::opaque_container(), Py_True);
    return result;
}

static PyTypeObject *QPointFList_TypeF()
{
    static PyTypeObject *type = createQPointFListType();
    return type;
}

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

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

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

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

extern "C" PythonToCppFunc isQPointFListPythonToCppConvertible(PyObject *pyArg)
{
    if (QPointFList_Check(pyArg))
        return PythonToCppQPointFList;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_quint32__PythonToCpp__QList_quint32__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<quint32>(), pyIn))
        return _QList_quint32__PythonToCpp__QList_quint32_;
    return {};
}

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

}
static void _QList_QFontDatabase_WritingSystem__PythonToCpp__QList_QFontDatabase_WritingSystem_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QFontDatabase::WritingSystem > *>(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;
        }
        ::QFontDatabase::WritingSystem cppItem{QFontDatabase::Any};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QFONTDATABASE_WRITINGSYSTEM_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QFontDatabase_WritingSystem__PythonToCpp__QList_QFontDatabase_WritingSystem__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtGuiTypes[SBK_QFONTDATABASE_WRITINGSYSTEM_IDX]))->converter, pyIn))
        return _QList_QFontDatabase_WritingSystem__PythonToCpp__QList_QFontDatabase_WritingSystem_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QPoint__PythonToCpp__QList_QPoint__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QPOINT_IDX], pyIn))
        return _QList_QPoint__PythonToCpp__QList_QPoint_;
    return {};
}


// Binding for QList<QPoint >

template <>
struct ShibokenContainerValueConverter<QPoint>
{
    static bool checkValue(PyObject *pyArg)
    {
        return SbkObject_TypeCheck(SbkPySide6_QtCoreTypes[SBK_QPOINT_IDX], pyArg);
    }

    static PyObject *convertValueToPython(const QPoint &cppArg)
    {
        return Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypes[SBK_QPOINT_IDX], &cppArg);
    }

    static std::optional<QPoint> convertValueToCpp(PyObject *pyArg)
    {
        Shiboken::Conversions::PythonToCppConversion pythonToCpp;
        if (!((pythonToCpp = Shiboken::Conversions::pythonToCppValueConversion(SbkPySide6_QtCoreTypes[SBK_QPOINT_IDX], (pyArg))))) {
            PyErr_SetString(PyExc_TypeError, "Wrong type passed to container conversion.");
            return {};
        }
        ::QPoint cppArg;
        pythonToCpp(pyArg, &cppArg);
        return cppArg;
    }
};

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

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

static PyType_Spec QPointList_spec = {
    "1:QtGui.QPointList",
    sizeof(ShibokenContainer),
    0,
    Py_TPFLAGS_DEFAULT,
    QPointList_slots
};

static inline PyTypeObject *createQPointListType()
{
    auto *result = reinterpret_cast<PyTypeObject *>(SbkType_FromSpec(&QPointList_spec));
    Py_INCREF(Py_True);
    PyDict_SetItem(result->tp_dict, Shiboken::PyMagicName::opaque_container(), Py_True);
    return result;
}

static PyTypeObject *QPointList_TypeF()
{
    static PyTypeObject *type = createQPointListType();
    return type;
}

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

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

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

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

extern "C" PythonToCppFunc isQPointListPythonToCppConvertible(PyObject *pyArg)
{
    if (QPointList_Check(pyArg))
        return PythonToCppQPointList;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QPolygonF__PythonToCpp__QList_QPolygonF__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QPOLYGONF_IDX], pyIn))
        return _QList_QPolygonF__PythonToCpp__QList_QPolygonF_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QPageRanges_Range__PythonToCpp__QList_QPageRanges_Range__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QPAGERANGES_RANGE_IDX], pyIn))
        return _QList_QPageRanges_Range__PythonToCpp__QList_QPageRanges_Range_;
    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<QSize >'.
static PyObject *_QList_QSize__CppToPython__QList_QSize_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QSize > *>(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_QSIZE_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QSize__PythonToCpp__QList_QSize__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QSIZE_IDX], pyIn))
        return _QList_QSize__PythonToCpp__QList_QSize_;
    return {};
}

// C++ to Python conversion for container type 'std::pair<qreal,QColor >'.
static PyObject *_std_pair_qreal_QColor__CppToPython__std_pair_qreal_QColor_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::std::pair<qreal,QColor > *>(cppIn);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    PyObject *pyOut = PyTuple_New(2);
    PyTuple_SET_ITEM(pyOut, 0, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), &cppInRef.first));
    PyTuple_SET_ITEM(pyOut, 1, Shiboken::Conversions::copyToPython(SbkPySide6_QtGuiTypes[SBK_QCOLOR_IDX], &cppInRef.second));
    return pyOut;
    // END of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    // ========================================================================

}
static void _std_pair_qreal_QColor__PythonToCpp__std_pair_qreal_QColor_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::std::pair<qreal,QColor > *>(cppOut);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), PySequence_Fast_GET_ITEM(pyIn, 0), &(cppOutRef.first));
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtGuiTypes[SBK_QCOLOR_IDX], PySequence_Fast_GET_ITEM(pyIn, 1), &(cppOutRef.second));
    // END of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    // ========================================================================

}
static PythonToCppFunc is__std_pair_qreal_QColor__PythonToCpp__std_pair_qreal_QColor__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertiblePairTypes(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), false, PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QCOLOR_IDX]))->converter, false, pyIn))
        return _std_pair_qreal_QColor__PythonToCpp__std_pair_qreal_QColor_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_std_pair_qreal_QColor___PythonToCpp__QList_std_pair_qreal_QColor___Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_STD_PAIR_QREAL_QCOLOR_IDX], pyIn))
        return _QList_std_pair_qreal_QColor___PythonToCpp__QList_std_pair_qreal_QColor__;
    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:QtGui.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<uint16_t >'.
static PyObject *_QList_uint16_t__CppToPython__QList_uint16_t_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<uint16_t > *>(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<uint16_t>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_uint16_t__PythonToCpp__QList_uint16_t__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<uint16_t>(), pyIn))
        return _QList_uint16_t__PythonToCpp__QList_uint16_t_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QAccessibleInterfacePTR__PythonToCpp__QList_QAccessibleInterfacePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QACCESSIBLEINTERFACE_IDX], pyIn))
        return _QList_QAccessibleInterfacePTR__PythonToCpp__QList_QAccessibleInterfacePTR_;
    return {};
}

// C++ to Python conversion for container type 'QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag> >'.
static PyObject *_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___CppToPython__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag__(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > *>(cppIn);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    PyObject *pyOut = PyTuple_New(2);
    PyTuple_SET_ITEM(pyOut, 0, Shiboken::Conversions::pointerToPython(SbkPySide6_QtGuiTypes[SBK_QACCESSIBLEINTERFACE_IDX], cppInRef.first));
    PyTuple_SET_ITEM(pyOut, 1, Shiboken::Conversions::copyToPython(PepType_PFTP(reinterpret_cast<PySideQFlagsType *>(SbkPySide6_QtGuiTypes[SBK_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX]))->converter, &cppInRef.second));
    return pyOut;
    // END of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    // ========================================================================

}
static void _QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___PythonToCpp__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag__(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > *>(cppOut);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtGuiTypes[SBK_QACCESSIBLEINTERFACE_IDX], PySequence_Fast_GET_ITEM(pyIn, 0), &(cppOutRef.first));
    Shiboken::Conversions::pythonToCppCopy(PepType_PFTP(reinterpret_cast<PySideQFlagsType *>(SbkPySide6_QtGuiTypes[SBK_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX]))->converter, PySequence_Fast_GET_ITEM(pyIn, 1), &(cppOutRef.second));
    // END of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    // ========================================================================

}
static PythonToCppFunc is__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___PythonToCpp__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertiblePairTypes(PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QACCESSIBLEINTERFACE_IDX]))->converter, true, PepType_PFTP(reinterpret_cast<PySideQFlagsType *>(SbkPySide6_QtGuiTypes[SBK_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX]))->converter, false, pyIn))
        return _QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___PythonToCpp__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag__;
    return {};
}

// C++ to Python conversion for container type 'QList<QPair< QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > >'.
static PyObject *_QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____CppToPython__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QPair< QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > > *>(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_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____PythonToCpp__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QPair< QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > > *>(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;
        }
        ::QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag> > cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____PythonToCpp__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX], pyIn))
        return _QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____PythonToCpp__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___;
    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<QLine >'.
static PyObject *_QList_QLine__CppToPython__QList_QLine_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QLine > *>(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_QLINE_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QLine__PythonToCpp__QList_QLine__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QLINE_IDX], pyIn))
        return _QList_QLine__PythonToCpp__QList_QLine_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QLineF__PythonToCpp__QList_QLineF__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QLINEF_IDX], pyIn))
        return _QList_QLineF__PythonToCpp__QList_QLineF_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QRect__PythonToCpp__QList_QRect__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QRECT_IDX], pyIn))
        return _QList_QRect__PythonToCpp__QList_QRect_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QRectF__PythonToCpp__QList_QRectF__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QRECTF_IDX], pyIn))
        return _QList_QRectF__PythonToCpp__QList_QRectF_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QKeySequence__PythonToCpp__QList_QKeySequence__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QKEYSEQUENCE_IDX], pyIn))
        return _QList_QKeySequence__PythonToCpp__QList_QKeySequence_;
    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<QUndoStack* >'.
static PyObject *_QList_QUndoStackPTR__CppToPython__QList_QUndoStackPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QUndoStack* > *>(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_QUNDOSTACK_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QUndoStackPTR__PythonToCpp__QList_QUndoStackPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QUNDOSTACK_IDX], pyIn))
        return _QList_QUndoStackPTR__PythonToCpp__QList_QUndoStackPTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QTextFramePTR__PythonToCpp__QList_QTextFramePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTFRAME_IDX], pyIn))
        return _QList_QTextFramePTR__PythonToCpp__QList_QTextFramePTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QTextBlock__PythonToCpp__QList_QTextBlock__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTBLOCK_IDX], pyIn))
        return _QList_QTextBlock__PythonToCpp__QList_QTextBlock_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QTextFormat__PythonToCpp__QList_QTextFormat__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QTEXTFORMAT_IDX], pyIn))
        return _QList_QTextFormat__PythonToCpp__QList_QTextFormat_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QScreenPTR__PythonToCpp__QList_QScreenPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QSCREEN_IDX], pyIn))
        return _QList_QScreenPTR__PythonToCpp__QList_QScreenPTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QOpenGLContextPTR__PythonToCpp__QList_QOpenGLContextPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QOPENGLCONTEXT_IDX], pyIn))
        return _QList_QOpenGLContextPTR__PythonToCpp__QList_QOpenGLContextPTR_;
    return {};
}

// C++ to Python conversion for container type 'QSet<QByteArray >'.
static PyObject *_QSet_QByteArray__CppToPython__QSet_QByteArray_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<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 _QSet_QByteArray__PythonToCpp__QSet_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<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__QSet_QByteArray__PythonToCpp__QSet_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], pyIn))
        return _QSet_QByteArray__PythonToCpp__QSet_QByteArray_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_constQInputDevicePTR__PythonToCpp__QList_constQInputDevicePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QINPUTDEVICE_IDX], pyIn))
        return _QList_constQInputDevicePTR__PythonToCpp__QList_constQInputDevicePTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QActionPTR__PythonToCpp__QList_QActionPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QACTION_IDX], pyIn))
        return _QList_QActionPTR__PythonToCpp__QList_QActionPTR_;
    return {};
}

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

}
static void _QList_QInputMethodEvent_Attribute__PythonToCpp__QList_QInputMethodEvent_Attribute_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QInputMethodEvent::Attribute > *>(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;
        }
        ::QInputMethodEvent::Attribute cppItem = ::QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, int(0), int(0));
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtGuiTypes[SBK_QINPUTMETHODEVENT_ATTRIBUTE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QInputMethodEvent_Attribute__PythonToCpp__QList_QInputMethodEvent_Attribute__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QINPUTMETHODEVENT_ATTRIBUTE_IDX], pyIn))
        return _QList_QInputMethodEvent_Attribute__PythonToCpp__QList_QInputMethodEvent_Attribute_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QEventPoint__PythonToCpp__QList_QEventPoint__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QEVENTPOINT_IDX], pyIn))
        return _QList_QEventPoint__PythonToCpp__QList_QEventPoint_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QWindowPTR__PythonToCpp__QList_QWindowPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtGuiTypes[SBK_QWINDOW_IDX], pyIn))
        return _QList_QWindowPTR__PythonToCpp__QList_QWindowPTR_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QPersistentModelIndex__PythonToCpp__QList_QPersistentModelIndex__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QPERSISTENTMODELINDEX_IDX], pyIn))
        return _QList_QPersistentModelIndex__PythonToCpp__QList_QPersistentModelIndex_;
    return {};
}

// C++ to Python conversion for container type 'QHash<int,QByteArray >'.
static PyObject *_QHash_int_QByteArray__CppToPython__QHash_int_QByteArray_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QHash<int,QByteArray > *>(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(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - cppmap_to_pymap_conversion - END

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

}
static PythonToCppFunc is__QHash_int_QByteArray__PythonToCpp__QHash_int_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX]))->converter, false, pyIn))
        return _QHash_int_QByteArray__PythonToCpp__QHash_int_QByteArray_;
    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     */ "QtGui",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ QtGui_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 *QtGui_SignatureStrings[] = {
    "PySide6.QtGui.qAlpha(rgb:unsigned int)->int",
    "PySide6.QtGui.qBlue(rgb:unsigned int)->int",
    "1:PySide6.QtGui.qGray(r:int,g:int,b:int)->int",
    "0:PySide6.QtGui.qGray(rgb:unsigned int)->int",
    "PySide6.QtGui.qGreen(rgb:unsigned int)->int",
    "PySide6.QtGui.qIsGray(rgb:unsigned int)->bool",
    "PySide6.QtGui.qPixelFormatAlpha(channelSize:uchar,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.UnsignedInteger)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatCmyk(channelSize:uchar,alfa:uchar=0,usage:PySide6.QtGui.QPixelFormat.AlphaUsage=QPixelFormat.IgnoresAlpha,position:PySide6.QtGui.QPixelFormat.AlphaPosition=QPixelFormat.AtBeginning,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.UnsignedInteger)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatGrayscale(channelSize:uchar,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.UnsignedInteger)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatHsl(channelSize:uchar,alfa:uchar=0,usage:PySide6.QtGui.QPixelFormat.AlphaUsage=QPixelFormat.IgnoresAlpha,position:PySide6.QtGui.QPixelFormat.AlphaPosition=QPixelFormat.AtBeginning,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.FloatingPoint)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatHsv(channelSize:uchar,alfa:uchar=0,usage:PySide6.QtGui.QPixelFormat.AlphaUsage=QPixelFormat.IgnoresAlpha,position:PySide6.QtGui.QPixelFormat.AlphaPosition=QPixelFormat.AtBeginning,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.FloatingPoint)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatRgba(red:uchar,green:uchar,blue:uchar,alfa:uchar,usage:PySide6.QtGui.QPixelFormat.AlphaUsage,position:PySide6.QtGui.QPixelFormat.AlphaPosition,pmul:PySide6.QtGui.QPixelFormat.AlphaPremultiplied=QPixelFormat.NotPremultiplied,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.UnsignedInteger)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qPixelFormatYuv(layout:PySide6.QtGui.QPixelFormat.YUVLayout,alfa:uchar=0,usage:PySide6.QtGui.QPixelFormat.AlphaUsage=QPixelFormat.IgnoresAlpha,position:PySide6.QtGui.QPixelFormat.AlphaPosition=QPixelFormat.AtBeginning,p_mul:PySide6.QtGui.QPixelFormat.AlphaPremultiplied=QPixelFormat.NotPremultiplied,typeInt:PySide6.QtGui.QPixelFormat.TypeInterpretation=QPixelFormat.UnsignedByte,b_order:PySide6.QtGui.QPixelFormat.ByteOrder=QPixelFormat.LittleEndian)->PySide6.QtGui.QPixelFormat",
    "PySide6.QtGui.qRed(rgb:unsigned int)->int",
    "PySide6.QtGui.qRgb(r:int,g:int,b:int)->unsigned int",
    "PySide6.QtGui.qRgba(r:int,g:int,b:int,a:int)->unsigned int",
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_QtGui()
{
    if (SbkPySide6_QtGuiModuleObject != nullptr)
        return SbkPySide6_QtGuiModuleObject;
    {
        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_QtGui_IDX_COUNT];
    SbkPySide6_QtGuiTypes = cppApi;

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

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

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

    // Initialize classes in the type system
    init_QtGuiQt(module);
    init_QVector4D(module);
    init_QVector3D(module);
    init_QVector2D(module);
    init_QUndoCommand(module);
    init_QTransform(module);
    init_QTextTableCell(module);
    init_QTextOption(module);
    init_QTextOption_Tab(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QTEXTOPTION_IDX])->tp_dict);
    init_QTextObjectInterface(module);
    init_QTextLine(module);
    init_QTextLength(module);
    init_QTextItem(module);
    init_QTextInlineObject(module);
    init_QTextFragment(module);
    init_QTextFormat(module);
    init_QTextListFormat(module);
    init_QTextFrameFormat(module);
    init_QTextTableFormat(module);
    init_QTextDocumentFragment(module);
    init_QTextCursor(module);
    init_QTextCharFormat(module);
    init_QTextTableCellFormat(module);
    init_QTextImageFormat(module);
    init_QTextBlockUserData(module);
    init_QTextBlockFormat(module);
    init_QTextBlock(module);
    init_QTextBlock_iterator(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QTEXTBLOCK_IDX])->tp_dict);
    init_QSurfaceFormat(module);
    init_QSurface(module);
    init_QStandardItem(module);
    init_QRgba64(module);
    init_QRegion(module);
    init_QRawFont(module);
    init_QQuaternion(module);
    init_QPolygonF(module);
    init_QPolygon(module);
    init_QPointingDeviceUniqueId(module);
    init_QPixmapCache(module);
    init_QPixmapCache_Key(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QPIXMAPCACHE_IDX])->tp_dict);
    init_QPixelFormat(module);
    init_QPen(module);
    init_QPalette(module);
    init_QPainterPathStroker(module);
    init_QPainterPath(module);
    init_QPainterPath_Element(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QPAINTERPATH_IDX])->tp_dict);
    init_QPaintEngineState(module);
    init_QPaintEngine(module);
    init_QPaintDevice(module);
    init_QPicture(module);
    init_QPagedPaintDevice(module);
    init_QPageSize(module);
    init_QPageRanges(module);
    init_QPageRanges_Range(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QPAGERANGES_IDX])->tp_dict);
    init_QOpenGLFunctions(module);
    init_QOpenGLExtraFunctions(module);
    init_QMatrix4x4(module);
    init_QMatrix4x3(module);
    init_QMatrix4x2(module);
    init_QMatrix3x4(module);
    init_QMatrix3x3(module);
    init_QMatrix3x2(module);
    init_QMatrix2x4(module);
    init_QMatrix2x3(module);
    init_QMatrix2x2(module);
    init_QImageIOHandler(module);
    init_QIconEngine(module);
    init_QGradient(module);
    init_QRadialGradient(module);
    init_QLinearGradient(module);
    init_QGlyphRun(module);
    init_QFontMetricsF(module);
    init_QFontMetrics(module);
    init_QFontInfo(module);
    init_QFontDatabase(module);
    init_QFont(module);
    init_QStaticText(module);
    init_QEventPoint(module);
    init_QDesktopServices(module);
    init_QCursor(module);
    init_QConicalGradient(module);
    init_QColorTransform(module);
    init_QColorSpace(module);
    init_QColor(module);
    init_QtGuiQColorConstants(module);
    init_QtGuiQColorConstants_Svg(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QtGuiQCOLORCONSTANTS_IDX])->tp_dict);
    init_QBrush(module);
    init_QAccessibleValueInterface(module);
    init_QAccessibleTextInterface(module);
    init_QAccessibleTableCellInterface(module);
    init_QAccessibleInterface(module);
    init_QAccessibleObject(module);
    init_QAccessibleEvent(module);
    init_QAccessibleValueChangeEvent(module);
    init_QAccessibleTextCursorEvent(module);
    init_QAccessibleTextUpdateEvent(module);
    init_QAccessibleTextSelectionEvent(module);
    init_QAccessibleTextRemoveEvent(module);
    init_QAccessibleTextInsertEvent(module);
    init_QAccessibleTableModelChangeEvent(module);
    init_QAccessibleStateChangeEvent(module);
    init_QAccessibleEditableTextInterface(module);
    init_QAccessibleActionInterface(module);
    init_QAccessible(module);
    init_QAccessible_State(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QACCESSIBLE_IDX])->tp_dict);
    init_QAbstractFileIconProvider(module);
    init_QIcon(module);
    init_QTextLayout(module);
    init_QTextLayout_FormatRange(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QTEXTLAYOUT_IDX])->tp_dict);
    init_QPixmap(module);
    init_QIconEngine_ScaledPixmapArgument(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QICONENGINE_IDX])->tp_dict);
    init_QImage(module);
    init_QBitmap(module);
    init_QPainter(module);
    init_QPainter_PixmapFragment(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QPAINTER_IDX])->tp_dict);
    init_QBackingStore(module);
    init_QPageLayout(module);
    init_QKeySequence(module);
    init_QWindow(module);
    init_QPaintDeviceWindow(module);
    init_QRasterWindow(module);
    init_QValidator(module);
    init_QRegularExpressionValidator(module);
    init_QIntValidator(module);
    init_QDoubleValidator(module);
    init_QUndoStack(module);
    init_QUndoGroup(module);
    init_QTextObject(module);
    init_QTextFrame(module);
    init_QTextTable(module);
    init_QTextFrame_iterator(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QTEXTFRAME_IDX])->tp_dict);
    init_QTextBlockGroup(module);
    init_QTextList(module);
    init_QTextDocument(module);
    init_QSyntaxHighlighter(module);
    init_QStyleHints(module);
    init_QShortcut(module);
    init_QSessionManager(module);
    init_QScreen(module);
    init_QPyTextObject(module);
    init_QPdfWriter(module);
    init_QOpenGLContextGroup(module);
    init_QOpenGLContext(module);
    init_QOffscreenSurface(module);
    init_QInputMethod(module);
    init_QInputDevice(module);
    init_QPointingDevice(module);
    init_QDrag(module);
    init_QClipboard(module);
    init_QActionGroup(module);
    init_QAction(module);
    init_QAbstractTextDocumentLayout(module);
    init_QAbstractTextDocumentLayout_Selection(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QABSTRACTTEXTDOCUMENTLAYOUT_IDX])->tp_dict);
    init_QAbstractTextDocumentLayout_PaintContext(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QABSTRACTTEXTDOCUMENTLAYOUT_IDX])->tp_dict);
    init_QWindowStateChangeEvent(module);
    init_QWhatsThisClickedEvent(module);
    init_QToolBarChangeEvent(module);
    init_QStatusTipEvent(module);
    init_QShowEvent(module);
    init_QShortcutEvent(module);
    init_QScrollPrepareEvent(module);
    init_QScrollEvent(module);
    init_QResizeEvent(module);
    init_QPlatformSurfaceEvent(module);
    init_QPaintEvent(module);
    init_QMoveEvent(module);
    init_QInputMethodQueryEvent(module);
    init_QInputMethodEvent(module);
    init_QInputMethodEvent_Attribute(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtGuiTypes[SBK_QINPUTMETHODEVENT_IDX])->tp_dict);
    init_QInputEvent(module);
    init_QPointerEvent(module);
    init_QTouchEvent(module);
    init_QSinglePointEvent(module);
    init_QWheelEvent(module);
    init_QTabletEvent(module);
    init_QNativeGestureEvent(module);
    init_QMouseEvent(module);
    init_QHoverEvent(module);
    init_QEnterEvent(module);
    init_QKeyEvent(module);
    init_QContextMenuEvent(module);
    init_QIconDragEvent(module);
    init_QHideEvent(module);
    init_QHelpEvent(module);
    init_QFocusEvent(module);
    init_QFileOpenEvent(module);
    init_QExposeEvent(module);
    init_QDropEvent(module);
    init_QDragMoveEvent(module);
    init_QDragEnterEvent(module);
    init_QDragLeaveEvent(module);
    init_QCloseEvent(module);
    init_QActionEvent(module);
    init_QGuiApplication(module);
    init_QTextDocumentWriter(module);
    init_QMovie(module);
    init_QImageWriter(module);
    init_QImageReader(module);
    init_QStandardItemModel(module);

    // Register converter for type 'PySide6.QtGui.WId'.
    SbkPySide6_QtGuiTypeConverters[SBK_WID_IDX] = Shiboken::Conversions::createConverter(&PyLong_Type, WId_CppToPython_WId);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_WID_IDX], "WId");
    // Add user defined implicit conversions to type converter.
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_WID_IDX],
        PyLong_PythonToCpp_WId,
        is_PyLong_PythonToCpp_WId_Convertible);


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

    // Register converter for type 'QList<QTextOption::Tab>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTOPTION_TAB_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextOption_Tab__CppToPython__QList_QTextOption_Tab_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTOPTION_TAB_IDX], "QList<QTextOption::Tab>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTOPTION_TAB_IDX],
        _QList_QTextOption_Tab__PythonToCpp__QList_QTextOption_Tab_,
        is__QList_QTextOption_Tab__PythonToCpp__QList_QTextOption_Tab__Convertible);

    // Register converter for type 'QList<QGlyphRun>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QGLYPHRUN_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QGlyphRun__CppToPython__QList_QGlyphRun_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QGLYPHRUN_IDX], "QList<QGlyphRun>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QGLYPHRUN_IDX],
        _QList_QGlyphRun__PythonToCpp__QList_QGlyphRun_,
        is__QList_QGlyphRun__PythonToCpp__QList_QGlyphRun__Convertible);

    // Register converter for type 'QList<QTextLength>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLENGTH_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextLength__CppToPython__QList_QTextLength_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLENGTH_IDX], "QList<QTextLength>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLENGTH_IDX],
        _QList_QTextLength__PythonToCpp__QList_QTextLength_,
        is__QList_QTextLength__PythonToCpp__QList_QTextLength__Convertible);

    // Register converter for type 'QMap<int,QVariant>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QMAP_INT_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_int_QVariant__CppToPython__QMap_int_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QMAP_INT_QVARIANT_IDX], "QMap<int,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QMAP_INT_QVARIANT_IDX],
        _QMap_int_QVariant__PythonToCpp__QMap_int_QVariant_,
        is__QMap_int_QVariant__PythonToCpp__QMap_int_QVariant__Convertible);

    // Register converter for type 'QList<QTextLayout::FormatRange>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLAYOUT_FORMATRANGE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextLayout_FormatRange__CppToPython__QList_QTextLayout_FormatRange_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLAYOUT_FORMATRANGE_IDX], "QList<QTextLayout::FormatRange>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTLAYOUT_FORMATRANGE_IDX],
        _QList_QTextLayout_FormatRange__PythonToCpp__QList_QTextLayout_FormatRange_,
        is__QList_QTextLayout_FormatRange__PythonToCpp__QList_QTextLayout_FormatRange__Convertible);

    // Register converter for type 'QPair<int,int>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_INT_INT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QPair_int_int__CppToPython__QPair_int_int_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_INT_INT_IDX], "QPair<int,int>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_INT_INT_IDX],
        _QPair_int_int__PythonToCpp__QPair_int_int_,
        is__QPair_int_int__PythonToCpp__QPair_int_int__Convertible);

    // Register converter for type 'QList<QStandardItem*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSTANDARDITEMPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QStandardItemPTR__CppToPython__QList_QStandardItemPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSTANDARDITEMPTR_IDX], "QList<QStandardItem*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSTANDARDITEMPTR_IDX],
        _QList_QStandardItemPTR__PythonToCpp__QList_QStandardItemPTR_,
        is__QList_QStandardItemPTR__PythonToCpp__QList_QStandardItemPTR__Convertible);

    // Register converter for type 'QList<QPointF>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINTF_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPointF__CppToPython__QList_QPointF_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINTF_IDX], "QList<QPointF>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINTF_IDX],
        _QList_QPointF__PythonToCpp__QList_QPointF_,
        is__QList_QPointF__PythonToCpp__QList_QPointF__Convertible);
    Shiboken::Conversions::setPythonToCppPointerFunctions(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINTF_IDX],
        PythonToCppQPointFList,
        isQPointFListPythonToCppConvertible);

    // Register converter for type 'QList<quint32>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUINT32_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_quint32__CppToPython__QList_quint32_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUINT32_IDX], "QList<quint32>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUINT32_IDX],
        _QList_quint32__PythonToCpp__QList_quint32_,
        is__QList_quint32__PythonToCpp__QList_quint32__Convertible);

    // Register converter for type 'QList<QFontDatabase::WritingSystem>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QFONTDATABASE_WRITINGSYSTEM_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QFontDatabase_WritingSystem__CppToPython__QList_QFontDatabase_WritingSystem_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QFONTDATABASE_WRITINGSYSTEM_IDX], "QList<QFontDatabase::WritingSystem>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QFONTDATABASE_WRITINGSYSTEM_IDX],
        _QList_QFontDatabase_WritingSystem__PythonToCpp__QList_QFontDatabase_WritingSystem_,
        is__QList_QFontDatabase_WritingSystem__PythonToCpp__QList_QFontDatabase_WritingSystem__Convertible);

    // Register converter for type 'QList<QPoint>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPoint__CppToPython__QList_QPoint_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINT_IDX], "QList<QPoint>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINT_IDX],
        _QList_QPoint__PythonToCpp__QList_QPoint_,
        is__QList_QPoint__PythonToCpp__QList_QPoint__Convertible);
    Shiboken::Conversions::setPythonToCppPointerFunctions(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOINT_IDX],
        PythonToCppQPointList,
        isQPointListPythonToCppConvertible);

    // Register converter for type 'QList<QPolygonF>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOLYGONF_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPolygonF__CppToPython__QList_QPolygonF_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOLYGONF_IDX], "QList<QPolygonF>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPOLYGONF_IDX],
        _QList_QPolygonF__PythonToCpp__QList_QPolygonF_,
        is__QList_QPolygonF__PythonToCpp__QList_QPolygonF__Convertible);

    // Register converter for type 'QList<QPageRanges::Range>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAGERANGES_RANGE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPageRanges_Range__CppToPython__QList_QPageRanges_Range_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAGERANGES_RANGE_IDX], "QList<QPageRanges::Range>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAGERANGES_RANGE_IDX],
        _QList_QPageRanges_Range__PythonToCpp__QList_QPageRanges_Range_,
        is__QList_QPageRanges_Range__PythonToCpp__QList_QPageRanges_Range__Convertible);

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

    // Register converter for type 'QList<QSize>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSIZE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSize__CppToPython__QList_QSize_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSIZE_IDX], "QList<QSize>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSIZE_IDX],
        _QList_QSize__PythonToCpp__QList_QSize_,
        is__QList_QSize__PythonToCpp__QList_QSize__Convertible);

    // Register converter for type 'std::pair<qreal,QColor>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_STD_PAIR_QREAL_QCOLOR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _std_pair_qreal_QColor__CppToPython__std_pair_qreal_QColor_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_STD_PAIR_QREAL_QCOLOR_IDX], "std::pair<qreal,QColor>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_STD_PAIR_QREAL_QCOLOR_IDX],
        _std_pair_qreal_QColor__PythonToCpp__std_pair_qreal_QColor_,
        is__std_pair_qreal_QColor__PythonToCpp__std_pair_qreal_QColor__Convertible);

    // Register converter for type 'QList<std::pair<qreal,QColor>>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_STD_PAIR_QREAL_QCOLOR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_std_pair_qreal_QColor___CppToPython__QList_std_pair_qreal_QColor__);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_STD_PAIR_QREAL_QCOLOR_IDX], "QList<std::pair<qreal,QColor>>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_STD_PAIR_QREAL_QCOLOR_IDX],
        _QList_std_pair_qreal_QColor___PythonToCpp__QList_std_pair_qreal_QColor__,
        is__QList_std_pair_qreal_QColor___PythonToCpp__QList_std_pair_qreal_QColor___Convertible);

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

    // Register converter for type 'QList<uint16_t>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_UINT16_T_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_uint16_t__CppToPython__QList_uint16_t_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_UINT16_T_IDX], "QList<uint16_t>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_UINT16_T_IDX],
        _QList_uint16_t__PythonToCpp__QList_uint16_t_,
        is__QList_uint16_t__PythonToCpp__QList_uint16_t__Convertible);

    // Register converter for type 'QList<QAccessibleInterface*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACCESSIBLEINTERFACEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QAccessibleInterfacePTR__CppToPython__QList_QAccessibleInterfacePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACCESSIBLEINTERFACEPTR_IDX], "QList<QAccessibleInterface*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACCESSIBLEINTERFACEPTR_IDX],
        _QList_QAccessibleInterfacePTR__PythonToCpp__QList_QAccessibleInterfacePTR_,
        is__QList_QAccessibleInterfacePTR__PythonToCpp__QList_QAccessibleInterfacePTR__Convertible);

    // Register converter for type 'QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag>>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___CppToPython__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag__);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX], "QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag>>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX],
        _QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___PythonToCpp__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag__,
        is__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___PythonToCpp__QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___Convertible);

    // Register converter for type 'QList<QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag>>>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____CppToPython__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX], "QList<QPair<QAccessibleInterface*,QFlags<QAccessible::RelationFlag>>>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPAIR_QACCESSIBLEINTERFACEPTR_QFLAGS_QACCESSIBLE_RELATIONFLAG_IDX],
        _QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____PythonToCpp__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag___,
        is__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____PythonToCpp__QList_QPair_QAccessibleInterfacePTR_QFlags_QAccessible_RelationFlag____Convertible);

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

    // Register converter for type 'QList<QLine>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QLine__CppToPython__QList_QLine_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINE_IDX], "QList<QLine>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINE_IDX],
        _QList_QLine__PythonToCpp__QList_QLine_,
        is__QList_QLine__PythonToCpp__QList_QLine__Convertible);

    // Register converter for type 'QList<QLineF>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINEF_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QLineF__CppToPython__QList_QLineF_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINEF_IDX], "QList<QLineF>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QLINEF_IDX],
        _QList_QLineF__PythonToCpp__QList_QLineF_,
        is__QList_QLineF__PythonToCpp__QList_QLineF__Convertible);

    // Register converter for type 'QList<QRect>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QRect__CppToPython__QList_QRect_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECT_IDX], "QList<QRect>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECT_IDX],
        _QList_QRect__PythonToCpp__QList_QRect_,
        is__QList_QRect__PythonToCpp__QList_QRect__Convertible);

    // Register converter for type 'QList<QRectF>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECTF_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QRectF__CppToPython__QList_QRectF_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECTF_IDX], "QList<QRectF>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QRECTF_IDX],
        _QList_QRectF__PythonToCpp__QList_QRectF_,
        is__QList_QRectF__PythonToCpp__QList_QRectF__Convertible);

    // Register converter for type 'QList<QKeySequence>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QKEYSEQUENCE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QKeySequence__CppToPython__QList_QKeySequence_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QKEYSEQUENCE_IDX], "QList<QKeySequence>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QKEYSEQUENCE_IDX],
        _QList_QKeySequence__PythonToCpp__QList_QKeySequence_,
        is__QList_QKeySequence__PythonToCpp__QList_QKeySequence__Convertible);

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

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

    // Register converter for type 'QList<QUndoStack*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUNDOSTACKPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QUndoStackPTR__CppToPython__QList_QUndoStackPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUNDOSTACKPTR_IDX], "QList<QUndoStack*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QUNDOSTACKPTR_IDX],
        _QList_QUndoStackPTR__PythonToCpp__QList_QUndoStackPTR_,
        is__QList_QUndoStackPTR__PythonToCpp__QList_QUndoStackPTR__Convertible);

    // Register converter for type 'QList<QTextFrame*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFRAMEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextFramePTR__CppToPython__QList_QTextFramePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFRAMEPTR_IDX], "QList<QTextFrame*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFRAMEPTR_IDX],
        _QList_QTextFramePTR__PythonToCpp__QList_QTextFramePTR_,
        is__QList_QTextFramePTR__PythonToCpp__QList_QTextFramePTR__Convertible);

    // Register converter for type 'QList<QTextBlock>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTBLOCK_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextBlock__CppToPython__QList_QTextBlock_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTBLOCK_IDX], "QList<QTextBlock>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTBLOCK_IDX],
        _QList_QTextBlock__PythonToCpp__QList_QTextBlock_,
        is__QList_QTextBlock__PythonToCpp__QList_QTextBlock__Convertible);

    // Register converter for type 'QList<QTextFormat>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFORMAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTextFormat__CppToPython__QList_QTextFormat_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFORMAT_IDX], "QList<QTextFormat>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QTEXTFORMAT_IDX],
        _QList_QTextFormat__PythonToCpp__QList_QTextFormat_,
        is__QList_QTextFormat__PythonToCpp__QList_QTextFormat__Convertible);

    // Register converter for type 'QList<QScreen*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSCREENPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QScreenPTR__CppToPython__QList_QScreenPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSCREENPTR_IDX], "QList<QScreen*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QSCREENPTR_IDX],
        _QList_QScreenPTR__PythonToCpp__QList_QScreenPTR_,
        is__QList_QScreenPTR__PythonToCpp__QList_QScreenPTR__Convertible);

    // Register converter for type 'QList<QOpenGLContext*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QOPENGLCONTEXTPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QOpenGLContextPTR__CppToPython__QList_QOpenGLContextPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QOPENGLCONTEXTPTR_IDX], "QList<QOpenGLContext*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QOPENGLCONTEXTPTR_IDX],
        _QList_QOpenGLContextPTR__PythonToCpp__QList_QOpenGLContextPTR_,
        is__QList_QOpenGLContextPTR__PythonToCpp__QList_QOpenGLContextPTR__Convertible);

    // Register converter for type 'QSet<QByteArray>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QSET_QBYTEARRAY_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_QByteArray__CppToPython__QSet_QByteArray_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QSET_QBYTEARRAY_IDX], "QSet<QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QSET_QBYTEARRAY_IDX],
        _QSet_QByteArray__PythonToCpp__QSet_QByteArray_,
        is__QSet_QByteArray__PythonToCpp__QSet_QByteArray__Convertible);

    // Register converter for type 'QList<const QInputDevice*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_CONSTQINPUTDEVICEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_constQInputDevicePTR__CppToPython__QList_constQInputDevicePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_CONSTQINPUTDEVICEPTR_IDX], "QList<const QInputDevice*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_CONSTQINPUTDEVICEPTR_IDX],
        _QList_constQInputDevicePTR__PythonToCpp__QList_constQInputDevicePTR_,
        is__QList_constQInputDevicePTR__PythonToCpp__QList_constQInputDevicePTR__Convertible);

    // Register converter for type 'QList<QAction*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACTIONPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QActionPTR__CppToPython__QList_QActionPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACTIONPTR_IDX], "QList<QAction*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QACTIONPTR_IDX],
        _QList_QActionPTR__PythonToCpp__QList_QActionPTR_,
        is__QList_QActionPTR__PythonToCpp__QList_QActionPTR__Convertible);

    // Register converter for type 'QList<QInputMethodEvent::Attribute>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QINPUTMETHODEVENT_ATTRIBUTE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QInputMethodEvent_Attribute__CppToPython__QList_QInputMethodEvent_Attribute_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QINPUTMETHODEVENT_ATTRIBUTE_IDX], "QList<QInputMethodEvent::Attribute>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QINPUTMETHODEVENT_ATTRIBUTE_IDX],
        _QList_QInputMethodEvent_Attribute__PythonToCpp__QList_QInputMethodEvent_Attribute_,
        is__QList_QInputMethodEvent_Attribute__PythonToCpp__QList_QInputMethodEvent_Attribute__Convertible);

    // Register converter for type 'QList<QEventPoint>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QEVENTPOINT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QEventPoint__CppToPython__QList_QEventPoint_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QEVENTPOINT_IDX], "QList<QEventPoint>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QEVENTPOINT_IDX],
        _QList_QEventPoint__PythonToCpp__QList_QEventPoint_,
        is__QList_QEventPoint__PythonToCpp__QList_QEventPoint__Convertible);

    // Register converter for type 'QList<QWindow*>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QWINDOWPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QWindowPTR__CppToPython__QList_QWindowPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QWINDOWPTR_IDX], "QList<QWindow*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QWINDOWPTR_IDX],
        _QList_QWindowPTR__PythonToCpp__QList_QWindowPTR_,
        is__QList_QWindowPTR__PythonToCpp__QList_QWindowPTR__Convertible);

    // Register converter for type 'QList<QPersistentModelIndex>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPERSISTENTMODELINDEX_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QPersistentModelIndex__CppToPython__QList_QPersistentModelIndex_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPERSISTENTMODELINDEX_IDX], "QList<QPersistentModelIndex>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QLIST_QPERSISTENTMODELINDEX_IDX],
        _QList_QPersistentModelIndex__PythonToCpp__QList_QPersistentModelIndex_,
        is__QList_QPersistentModelIndex__PythonToCpp__QList_QPersistentModelIndex__Convertible);

    // Register converter for type 'QHash<int,QByteArray>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QHASH_INT_QBYTEARRAY_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_int_QByteArray__CppToPython__QHash_int_QByteArray_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QHASH_INT_QBYTEARRAY_IDX], "QHash<int,QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QHASH_INT_QBYTEARRAY_IDX],
        _QHash_int_QByteArray__PythonToCpp__QHash_int_QByteArray_,
        is__QHash_int_QByteArray__PythonToCpp__QHash_int_QByteArray__Convertible);

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

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

    // Register converter for type 'QMap<QString,QVariant>'.
    SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QMAP_QSTRING_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QString_QVariant__CppToPython__QMap_QString_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_QMAP_QSTRING_QVARIANT_IDX], "QMap<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtGuiTypeConverters[SBK_QTGUI_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 *>(QPointFList_TypeF());
    Py_XINCREF(ob_type);
    PyModule_AddObject(module, "QPointFList", ob_type);
    ob_type = reinterpret_cast<PyObject *>(QPointList_TypeF());
    Py_XINCREF(ob_type);
    PyModule_AddObject(module, "QPointList", ob_type);
    ob_type = reinterpret_cast<PyObject *>(QIntList_TypeF());
    Py_XINCREF(ob_type);
    PyModule_AddObject(module, "QIntList", ob_type);


    // Extended implicit conversions for PySide6.QtCore.QPointF.
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtCoreTypes[SBK_QPOINTF_IDX],
        QPainterPath_Element_PythonToCpp_PySide6_QtCore_QPointF,
        is_QPainterPath_Element_PythonToCpp_PySide6_QtCore_QPointF_Convertible);

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_QtGuiTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_QtGuiTypeConverters);

    // Static field initialization
    init_QtGuiQColorConstantsStaticFields();
    init_QtGuiQColorConstants_SvgStaticFields();

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

    FinishSignatureInitialization(module, QtGui_SignatureStrings);

    return module;
}
