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

#include <QtQml/qjsengine.h>
#include <QtQml/qqml.h>


// Extra includes
#include <QtQml>

// Current module's type array.
PyTypeObject **SbkPySide6_QtQmlTypes = nullptr;
// Current module's PyObject pointer.
PyObject *SbkPySide6_QtQmlModuleObject = nullptr;
// Current module's converter array.
SbkConverter **SbkPySide6_QtQmlTypeConverters = nullptr;
// Begin code injection
#include "pysideqmlregistertype.h"
#include "pysideqmllistproperty.h"
#include "pysideqmluncreatable.h"
#include "pysideqmlvolatilebool.h"
// End of code injection

void cleanTypesAttributes() {
    for (int i = 0, imax = SBK_QtQml_IDX_COUNT; i < imax; i++) {
        PyObject *pyType = reinterpret_cast<PyObject *>(SbkPySide6_QtQmlTypes[i]);
        Shiboken::AutoDecRef attrName(Py_BuildValue("s", "staticMetaObject"));
        if (pyType && PyObject_HasAttr(pyType, attrName))
            PyObject_SetAttr(pyType, attrName, Py_None);
    }
}
// Global functions ------------------------------------------------------------
static PyObject *SbkQtQmlModule_QmlAnonymous(PyObject *self, PyObject *pyArg)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.QmlAnonymous";
    SBK_UNUSED(fullName)
    int overloadId = -1;
    Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    SBK_UNUSED(pythonToCpp)

    // Overloaded function decisor
    // 0: QmlAnonymous(PyObject*)->PyObject*
    if (PyObject_Check(pyArg)) {
        overloadId = 0; // QmlAnonymous(PyObject*)
    }

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

    // Call function/method
    {

        if (!PyErr_Occurred()) {
            // QmlAnonymous(PyObject*)
            // Begin code injection
            // ========================================================================
            // START of custom code block [file: ../glue/qtqml.cpp (qmlanonymous)]
            pyResult = PySide::qmlAnonymousMacro(pyArg);
            // END of custom code block [file: ../glue/qtqml.cpp (qmlanonymous)]
            // ========================================================================
            // End of code injection

        }
    }

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

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

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

    // Overloaded function decisor
    // 0: QmlElement(PyObject*)->PyObject*
    if (PyObject_Check(pyArg)) {
        overloadId = 0; // QmlElement(PyObject*)
    }

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

    // Call function/method
    {

        if (!PyErr_Occurred()) {
            // QmlElement(PyObject*)
            // Begin code injection
            // ========================================================================
            // START of custom code block [file: ../glue/qtqml.cpp (qmlelement)]
            pyResult = PySide::qmlElementMacro(pyArg);
            // END of custom code block [file: ../glue/qtqml.cpp (qmlelement)]
            // ========================================================================
            // End of code injection

        }
    }

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

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

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

    // Overloaded function decisor
    // 0: QmlSingleton(PyObject*)->PyObject*
    if (PyObject_Check(pyArg)) {
        overloadId = 0; // QmlSingleton(PyObject*)
    }

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

    // Call function/method
    {

        if (!PyErr_Occurred()) {
            // QmlSingleton(PyObject*)
            // Begin code injection
            // ========================================================================
            // START of custom code block [file: ../glue/qtqml.cpp (qmlsingleton)]
            pyResult = PySide::qmlSingletonMacro(pyArg);
            // END of custom code block [file: ../glue/qtqml.cpp (qmlsingleton)]
            // ========================================================================
            // End of code injection

        }
    }

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

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

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

    // Overloaded function decisor
    // 0: qjsEngine(const QObject*)->QJSEngine*
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppPointerConversion(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], (pyArg)))) {
        overloadId = 0; // qjsEngine(const QObject*)
    }

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

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QObject *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (!PyErr_Occurred()) {
            // qjsEngine(const QObject*)
            QJSEngine * cppResult = qjsEngine(cppArg0);
            pyResult = Shiboken::Conversions::pointerToPython(SbkPySide6_QtQmlTypes[SBK_QJSENGINE_IDX], cppResult);
        }
    }

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

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

static PyObject *SbkQtQmlModule_qmlClearTypeRegistrations(PyObject *self)
{
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.qmlClearTypeRegistrations";
    SBK_UNUSED(fullName)

    // Call function/method
    {

        if (!PyErr_Occurred()) {
            // qmlClearTypeRegistrations()
            qmlClearTypeRegistrations();
        }
    }

    if (PyErr_Occurred()) {
        return {};
    }
    Py_RETURN_NONE;
}

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

    // Overloaded function decisor
    // 0: qmlContext(const QObject*)->QQmlContext*
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppPointerConversion(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], (pyArg)))) {
        overloadId = 0; // qmlContext(const QObject*)
    }

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

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QObject *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (!PyErr_Occurred()) {
            // qmlContext(const QObject*)
            QQmlContext * cppResult = qmlContext(cppArg0);
            pyResult = Shiboken::Conversions::pointerToPython(SbkPySide6_QtQmlTypes[SBK_QQMLCONTEXT_IDX], cppResult);
        }
    }

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

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

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

    // Overloaded function decisor
    // 0: qmlEngine(const QObject*)->QQmlEngine*
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppPointerConversion(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], (pyArg)))) {
        overloadId = 0; // qmlEngine(const QObject*)
    }

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

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QObject *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (!PyErr_Occurred()) {
            // qmlEngine(const QObject*)
            QQmlEngine * cppResult = qmlEngine(cppArg0);
            pyResult = Shiboken::Conversions::pointerToPython(SbkPySide6_QtQmlTypes[SBK_QQMLENGINE_IDX], cppResult);
        }
    }

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

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

static PyObject *SbkQtQmlModule_qmlProtectModule(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.qmlProtectModule";
    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 (!PyArg_UnpackTuple(args, "qmlProtectModule", 2, 2, &(pyArgs[0]), &(pyArgs[1])))
        return {};


    // Overloaded function decisor
    // 0: qmlProtectModule(const char*,int)->bool
    if (numArgs == 2
        && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[1])))) {
        overloadId = 0; // qmlProtectModule(const char*,int)
    }

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

    // Call function/method
    {
        const char* cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        int cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);

        if (!PyErr_Occurred()) {
            // qmlProtectModule(const char*,int)
            bool cppResult = qmlProtectModule(cppArg0, cppArg1);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
        }
    }

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

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

static PyObject *SbkQtQmlModule_qmlRegisterModule(PyObject *self, PyObject *args)
{
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.qmlRegisterModule";
    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, "qmlRegisterModule", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2])))
        return {};


    // Overloaded function decisor
    // 0: qmlRegisterModule(const char*,int,int)
    if (numArgs == 3
        && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (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; // qmlRegisterModule(const char*,int,int)
    }

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

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

        if (!PyErr_Occurred()) {
            // qmlRegisterModule(const char*,int,int)
            qmlRegisterModule(cppArg0, cppArg1, cppArg2);
        }
    }

    if (PyErr_Occurred()) {
        return {};
    }
    Py_RETURN_NONE;

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

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

    // invalid argument lengths


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


    // Overloaded function decisor
    // 0: qmlRegisterSingletonInstance(PyTypeObject,const char*,int,int,const char*,PyObject*)->int
    if (numArgs == 6
        && PyType_Check(pyArgs[0])
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))
        && PyObject_Check(pyArgs[5])) {
        overloadId = 0; // qmlRegisterSingletonInstance(PyTypeObject,const char*,int,int,const char*,PyObject*)
    }

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

    // Call function/method
    {
        const char* cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        SBK_UNUSED(cppArg1)
        int cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        SBK_UNUSED(cppArg2)
        int cppArg3;
        pythonToCpp[3](pyArgs[3], &cppArg3);
        SBK_UNUSED(cppArg3)
        const char* cppArg4;
        pythonToCpp[4](pyArgs[4], &cppArg4);
        SBK_UNUSED(cppArg4)

        if (!PyErr_Occurred()) {
            // qmlRegisterSingletonInstance(PyTypeObject,const char*,int,int,const char*,PyObject*)
            // Begin code injection
            // ========================================================================
            // START of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletoninstance)]
            int cppResult = PySide::qmlRegisterSingletonInstance(pyArgs[0], cppArg1, cppArg2, cppArg3, cppArg4, pyArgs[5]);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            // END of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletoninstance)]
            // ========================================================================
            // End of code injection

        }
    }

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

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

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

    // invalid argument lengths


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


    // Overloaded function decisor
    // 0: qmlRegisterSingletonType(QUrl,const char*,int,int,const char*)->int
    // 1: qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*,PyObject*)->int
    // 2: qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*)->int
    // 3: qmlRegisterSingletonType(const char*,int,int,const char*,PyObject*)->int
    if (numArgs == 5
        && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && Shiboken::String::check(pyArgs[3]) && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[3])))
        && PyObject_Check(pyArgs[4])) {
        overloadId = 3; // qmlRegisterSingletonType(const char*,int,int,const char*,PyObject*)
    } else if (numArgs >= 5
        && PyType_Check(pyArgs[0])
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))) {
        if (numArgs == 5) {
            overloadId = 2; // qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*)
        } else if (numArgs == 6
            && PyObject_Check(pyArgs[5])) {
            overloadId = 1; // qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*,PyObject*)
        }
    } else if (numArgs == 5
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(SbkPySide6_QtCoreTypes[SBK_QURL_IDX], (pyArgs[0])))
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))) {
        overloadId = 0; // qmlRegisterSingletonType(QUrl,const char*,int,int,const char*)
    }

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

    // Call function/method
    switch (overloadId) {
        case 0: // qmlRegisterSingletonType(const QUrl & url, const char * uri, int versionMajor, int versionMinor, const char * qmlName)
        {
            if (!Shiboken::Object::isValid(pyArgs[0]))
                return {};
            ::QUrl cppArg0_local;
            ::QUrl *cppArg0 = &cppArg0_local;
            if (pythonToCpp[0].isValue())
                pythonToCpp[0](pyArgs[0], &cppArg0_local);
            else
                pythonToCpp[0](pyArgs[0], &cppArg0);

            const char* cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            int cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            const char* cppArg4;
            pythonToCpp[4](pyArgs[4], &cppArg4);

            if (!PyErr_Occurred()) {
                // qmlRegisterSingletonType(QUrl,const char*,int,int,const char*)
                int cppResult = qmlRegisterSingletonType(*cppArg0, cppArg1, cppArg2, cppArg3, cppArg4);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            }
            break;
        }
        case 1: // qmlRegisterSingletonType(PyTypeObject arg__1, const char * arg__2, int arg__3, int arg__4, const char * arg__5, PyObject * arg__6)
        {
            const char* cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            SBK_UNUSED(cppArg1)
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            SBK_UNUSED(cppArg2)
            int cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            SBK_UNUSED(cppArg3)
            const char* cppArg4;
            pythonToCpp[4](pyArgs[4], &cppArg4);
            SBK_UNUSED(cppArg4)

            if (!PyErr_Occurred()) {
                // qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*,PyObject*)
                // Begin code injection
                // ========================================================================
                // START of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qobject_callback)]
                int cppResult = PySide::qmlRegisterSingletonType(pyArgs[0], cppArg1, cppArg2, cppArg3, cppArg4, pyArgs[5], true, true);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
                // END of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qobject_callback)]
                // ========================================================================
                // End of code injection

            }
            break;
        }
        case 2: // qmlRegisterSingletonType(PyTypeObject arg__1, const char * arg__2, int arg__3, int arg__4, const char * arg__5)
        {
            const char* cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            SBK_UNUSED(cppArg1)
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            SBK_UNUSED(cppArg2)
            int cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            SBK_UNUSED(cppArg3)
            const char* cppArg4;
            pythonToCpp[4](pyArgs[4], &cppArg4);
            SBK_UNUSED(cppArg4)

            if (!PyErr_Occurred()) {
                // qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*)
                // Begin code injection
                // ========================================================================
                // START of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qobject_nocallback)]
                int cppResult = PySide::qmlRegisterSingletonType(pyArgs[0], cppArg1, cppArg2, cppArg3, cppArg4, nullptr, true, false);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
                // END of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qobject_nocallback)]
                // ========================================================================
                // End of code injection

            }
            break;
        }
        case 3: // qmlRegisterSingletonType(const char * arg__1, int arg__2, int arg__3, const char * arg__4, PyObject * arg__5)
        {
            const char* cppArg0;
            pythonToCpp[0](pyArgs[0], &cppArg0);
            SBK_UNUSED(cppArg0)
            int cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            SBK_UNUSED(cppArg1)
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            SBK_UNUSED(cppArg2)
            const char* cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            SBK_UNUSED(cppArg3)

            if (!PyErr_Occurred()) {
                // qmlRegisterSingletonType(const char*,int,int,const char*,PyObject*)
                // Begin code injection
                // ========================================================================
                // START of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qjsvalue)]
                int cppResult = PySide::qmlRegisterSingletonType(nullptr, cppArg0, cppArg1, cppArg2, cppArg3, pyArgs[4], false, true);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
                // END of custom code block [file: ../glue/qtqml.cpp (qmlregistersingletontype_qjsvalue)]
                // ========================================================================
                // End of code injection

            }
            break;
        }
    }

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

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

static PyObject *SbkQtQmlModule_qmlRegisterType(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.qmlRegisterType";
    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 (!PyArg_UnpackTuple(args, "qmlRegisterType", 5, 5, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4])))
        return {};


    // Overloaded function decisor
    // 0: qmlRegisterType(QUrl,const char*,int,int,const char*)->int
    // 1: qmlRegisterType(PyTypeObject,const char*,int,int,const char*)->int
    if (numArgs == 5
        && PyType_Check(pyArgs[0])
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))) {
        overloadId = 1; // qmlRegisterType(PyTypeObject,const char*,int,int,const char*)
    } else if (numArgs == 5
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(SbkPySide6_QtCoreTypes[SBK_QURL_IDX], (pyArgs[0])))
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))) {
        overloadId = 0; // qmlRegisterType(QUrl,const char*,int,int,const char*)
    }

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

    // Call function/method
    switch (overloadId) {
        case 0: // qmlRegisterType(const QUrl & url, const char * uri, int versionMajor, int versionMinor, const char * qmlName)
        {
            if (!Shiboken::Object::isValid(pyArgs[0]))
                return {};
            ::QUrl cppArg0_local;
            ::QUrl *cppArg0 = &cppArg0_local;
            if (pythonToCpp[0].isValue())
                pythonToCpp[0](pyArgs[0], &cppArg0_local);
            else
                pythonToCpp[0](pyArgs[0], &cppArg0);

            const char* cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            int cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            const char* cppArg4;
            pythonToCpp[4](pyArgs[4], &cppArg4);

            if (!PyErr_Occurred()) {
                // qmlRegisterType(QUrl,const char*,int,int,const char*)
                int cppResult = qmlRegisterType(*cppArg0, cppArg1, cppArg2, cppArg3, cppArg4);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            }
            break;
        }
        case 1: // qmlRegisterType(PyTypeObject arg__1, const char * arg__2, int arg__3, int arg__4, const char * arg__5)
        {
            const char* cppArg1;
            pythonToCpp[1](pyArgs[1], &cppArg1);
            SBK_UNUSED(cppArg1)
            int cppArg2;
            pythonToCpp[2](pyArgs[2], &cppArg2);
            SBK_UNUSED(cppArg2)
            int cppArg3;
            pythonToCpp[3](pyArgs[3], &cppArg3);
            SBK_UNUSED(cppArg3)
            const char* cppArg4;
            pythonToCpp[4](pyArgs[4], &cppArg4);
            SBK_UNUSED(cppArg4)

            if (!PyErr_Occurred()) {
                // qmlRegisterType(PyTypeObject,const char*,int,int,const char*)
                // Begin code injection
                // ========================================================================
                // START of custom code block [file: ../glue/qtqml.cpp (qmlregistertype)]
                int cppResult = PySide::qmlRegisterType(pyArgs[0], cppArg1, cppArg2, cppArg3, cppArg4);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
                // END of custom code block [file: ../glue/qtqml.cpp (qmlregistertype)]
                // ========================================================================
                // End of code injection

            }
            break;
        }
    }

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

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

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

    // invalid argument lengths


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


    // Overloaded function decisor
    // 0: qmlRegisterUncreatableMetaObject(QMetaObject,const char*,int,int,const char*,QString)->int
    if (numArgs == 6
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(SbkPySide6_QtCoreTypes[SBK_QMETAOBJECT_IDX], (pyArgs[0])))
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))
        && (pythonToCpp[5] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], (pyArgs[5])))) {
        overloadId = 0; // qmlRegisterUncreatableMetaObject(QMetaObject,const char*,int,int,const char*,QString)
    }

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

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArgs[0]))
            return {};
        ::QMetaObject *cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        const char* cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        int cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        int cppArg3;
        pythonToCpp[3](pyArgs[3], &cppArg3);
        const char* cppArg4;
        pythonToCpp[4](pyArgs[4], &cppArg4);
        ::QString cppArg5;
        pythonToCpp[5](pyArgs[5], &cppArg5);

        if (!PyErr_Occurred()) {
            // qmlRegisterUncreatableMetaObject(QMetaObject,const char*,int,int,const char*,QString)
            int cppResult = qmlRegisterUncreatableMetaObject(*cppArg0, cppArg1, cppArg2, cppArg3, cppArg4, cppArg5);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
        }
    }

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

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

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

    // invalid argument lengths


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


    // Overloaded function decisor
    // 0: qmlRegisterUncreatableType(PyTypeObject,const char*,int,int,const char*,const char*)->int
    if (numArgs == 6
        && PyType_Check(pyArgs[0])
        && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[2])))
        && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[3])))
        && Shiboken::String::check(pyArgs[4]) && (pythonToCpp[4] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[4])))
        && Shiboken::String::check(pyArgs[5]) && (pythonToCpp[5] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), (pyArgs[5])))) {
        overloadId = 0; // qmlRegisterUncreatableType(PyTypeObject,const char*,int,int,const char*,const char*)
    }

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

    // Call function/method
    {
        const char* cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        SBK_UNUSED(cppArg1)
        int cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        SBK_UNUSED(cppArg2)
        int cppArg3;
        pythonToCpp[3](pyArgs[3], &cppArg3);
        SBK_UNUSED(cppArg3)
        const char* cppArg4;
        pythonToCpp[4](pyArgs[4], &cppArg4);
        SBK_UNUSED(cppArg4)
        const char* cppArg5;
        pythonToCpp[5](pyArgs[5], &cppArg5);
        SBK_UNUSED(cppArg5)

        if (!PyErr_Occurred()) {
            // qmlRegisterUncreatableType(PyTypeObject,const char*,int,int,const char*,const char*)
            // Begin code injection
            // ========================================================================
            // START of custom code block [file: ../glue/qtqml.cpp (qmlregisteruncreatabletype)]
            int cppResult = PySide::qmlRegisterType(pyArgs[0], cppArg1, cppArg2, cppArg3, cppArg4, cppArg5, false);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
            // END of custom code block [file: ../glue/qtqml.cpp (qmlregisteruncreatabletype)]
            // ========================================================================
            // End of code injection

        }
    }

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

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

static PyObject *SbkQtQmlModule_qmlTypeId(PyObject *self, PyObject *args)
{
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    static const char *fullName = "PySide6.QtQml.qmlTypeId";
    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, "qmlTypeId", 4, 4, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3])))
        return {};


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

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

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

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

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

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


static PyMethodDef QtQml_methods[] = {
    {"QmlAnonymous", reinterpret_cast<PyCFunction>(SbkQtQmlModule_QmlAnonymous), METH_O},
    {"QmlElement", reinterpret_cast<PyCFunction>(SbkQtQmlModule_QmlElement), METH_O},
    {"QmlSingleton", reinterpret_cast<PyCFunction>(SbkQtQmlModule_QmlSingleton), METH_O},
    {"qjsEngine", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qjsEngine), METH_O},
    {"qmlClearTypeRegistrations", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlClearTypeRegistrations), METH_NOARGS},
    {"qmlContext", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlContext), METH_O},
    {"qmlEngine", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlEngine), METH_O},
    {"qmlProtectModule", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlProtectModule), METH_VARARGS},
    {"qmlRegisterModule", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterModule), METH_VARARGS},
    {"qmlRegisterSingletonInstance", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterSingletonInstance), METH_VARARGS},
    {"qmlRegisterSingletonType", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterSingletonType), METH_VARARGS},
    {"qmlRegisterType", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterType), METH_VARARGS},
    {"qmlRegisterUncreatableMetaObject", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterUncreatableMetaObject), METH_VARARGS},
    {"qmlRegisterUncreatableType", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlRegisterUncreatableType), METH_VARARGS},
    {"qmlTypeId", reinterpret_cast<PyCFunction>(SbkQtQmlModule_qmlTypeId), METH_VARARGS},
    {0} // Sentinel
};

// Classes initialization functions ------------------------------------------------------------
void init_QQmlTypesExtensionInterface(PyObject *module);
void init_QQmlScriptString(PyObject *module);
void init_QQmlPropertyValueSource(PyObject *module);
void init_QQmlProperty(PyObject *module);
void init_QQmlParserStatus(PyObject *module);
void init_QQmlNetworkAccessManagerFactory(PyObject *module);
void init_QQmlListReference(PyObject *module);
void init_QQmlIncubator(PyObject *module);
void init_QQmlIncubationController(PyObject *module);
void init_QQmlFile(PyObject *module);
void init_QQmlExtensionInterface(PyObject *module);
void init_QQmlError(PyObject *module);
void init_QQmlDebuggingEnabler(PyObject *module);
void init_QQmlAbstractUrlInterceptor(PyObject *module);
void init_QJSValueIterator(PyObject *module);
void init_QJSValue(PyObject *module);
void init_QJSPrimitiveValue(PyObject *module);
void init_QJSManagedValue(PyObject *module);
void init_QQmlPropertyMap(PyObject *module);
void init_QQmlImageProviderBase(PyObject *module);
void init_QQmlFileSelector(PyObject *module);
void init_QQmlExtensionPlugin(PyObject *module);
void init_QQmlExpression(PyObject *module);
void init_QQmlContext(PyObject *module);
void init_QQmlComponent(PyObject *module);
void init_QJSEngine(PyObject *module);
void init_QQmlEngine(PyObject *module);
void init_QQmlApplicationEngine(PyObject *module);

// Enum definitions ------------------------------------------------------------
static void QQmlModuleImportSpecialVersions_PythonToCpp_QQmlModuleImportSpecialVersions(PyObject *pyIn, void *cppOut)
{
    *reinterpret_cast<::QQmlModuleImportSpecialVersions *>(cppOut) =
        static_cast<::QQmlModuleImportSpecialVersions>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_QQmlModuleImportSpecialVersions_PythonToCpp_QQmlModuleImportSpecialVersions_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX]))
        return QQmlModuleImportSpecialVersions_PythonToCpp_QQmlModuleImportSpecialVersions;
    return {};
}
static PyObject *QQmlModuleImportSpecialVersions_CppToPython_QQmlModuleImportSpecialVersions(const void *cppIn)
{
    const int castCppIn = int(*reinterpret_cast<const ::QQmlModuleImportSpecialVersions *>(cppIn));
    return Shiboken::Enum::newItem(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX], castCppIn);

}



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

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

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

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

}
static PythonToCppFunc is__QList_QQmlError__PythonToCpp__QList_QQmlError__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtQmlTypes[SBK_QQMLERROR_IDX], pyIn))
        return _QList_QQmlError__PythonToCpp__QList_QQmlError_;
    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 {};
}

// C++ to Python conversion for container type 'QHash<QString,QVariant >'.
static PyObject *_QHash_QString_QVariant__CppToPython__QHash_QString_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QHash<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 _QHash_QString_QVariant__PythonToCpp__QHash_QString_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QHash<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__QHash_QString_QVariant__PythonToCpp__QHash_QString_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], false, SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], false, pyIn))
        return _QHash_QString_QVariant__PythonToCpp__QHash_QString_QVariant_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QJSValue__PythonToCpp__QList_QJSValue__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtQmlTypes[SBK_QJSVALUE_IDX], pyIn))
        return _QList_QJSValue__PythonToCpp__QList_QJSValue_;
    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<QQmlAbstractUrlInterceptor* >'.
static PyObject *_QList_QQmlAbstractUrlInterceptorPTR__CppToPython__QList_QQmlAbstractUrlInterceptorPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QQmlAbstractUrlInterceptor* > *>(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_QtQmlTypes[SBK_QQMLABSTRACTURLINTERCEPTOR_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QQmlAbstractUrlInterceptorPTR__PythonToCpp__QList_QQmlAbstractUrlInterceptorPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtQmlTypes[SBK_QQMLABSTRACTURLINTERCEPTOR_IDX], pyIn))
        return _QList_QQmlAbstractUrlInterceptorPTR__PythonToCpp__QList_QQmlAbstractUrlInterceptorPTR_;
    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 {};
}


static struct PyModuleDef moduledef = {
    /* m_base     */ PyModuleDef_HEAD_INIT,
    /* m_name     */ "QtQml",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ QtQml_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 *QtQml_SignatureStrings[] = {
    "PySide6.QtQml.QmlAnonymous(arg__1:PyObject)->PyObject",
    "PySide6.QtQml.QmlElement(arg__1:PyObject)->PyObject",
    "PySide6.QtQml.QmlSingleton(arg__1:PyObject)->PyObject",
    "PySide6.QtQml.qjsEngine(arg__1:PySide6.QtCore.QObject)->Optional[PySide6.QtQml.QJSEngine]",
    "PySide6.QtQml.qmlClearTypeRegistrations()",
    "PySide6.QtQml.qmlContext(arg__1:PySide6.QtCore.QObject)->Optional[PySide6.QtQml.QQmlContext]",
    "PySide6.QtQml.qmlEngine(arg__1:PySide6.QtCore.QObject)->Optional[PySide6.QtQml.QQmlEngine]",
    "PySide6.QtQml.qmlProtectModule(uri:char*,majVersion:int)->bool",
    "PySide6.QtQml.qmlRegisterModule(uri:char*,versionMajor:int,versionMinor:int)",
    "PySide6.QtQml.qmlRegisterSingletonInstance(arg__1:PyTypeObject,arg__2:char*,arg__3:int,arg__4:int,arg__5:char*,arg__6:PyObject)->int",
    "3:PySide6.QtQml.qmlRegisterSingletonType(url:typing.Union[PySide6.QtCore.QUrl, QString],uri:char*,versionMajor:int,versionMinor:int,qmlName:char*)->int",
    "2:PySide6.QtQml.qmlRegisterSingletonType(arg__1:PyTypeObject,arg__2:char*,arg__3:int,arg__4:int,arg__5:char*,arg__6:PyObject)->int",
    "1:PySide6.QtQml.qmlRegisterSingletonType(arg__1:PyTypeObject,arg__2:char*,arg__3:int,arg__4:int,arg__5:char*)->int",
    "0:PySide6.QtQml.qmlRegisterSingletonType(arg__1:char*,arg__2:int,arg__3:int,arg__4:char*,arg__5:PyObject)->int",
    "1:PySide6.QtQml.qmlRegisterType(url:typing.Union[PySide6.QtCore.QUrl, QString],uri:char*,versionMajor:int,versionMinor:int,qmlName:char*)->int",
    "0:PySide6.QtQml.qmlRegisterType(arg__1:PyTypeObject,arg__2:char*,arg__3:int,arg__4:int,arg__5:char*)->int",
    "PySide6.QtQml.qmlRegisterUncreatableMetaObject(staticMetaObject:PySide6.QtCore.QMetaObject,uri:char*,versionMajor:int,versionMinor:int,qmlName:char*,reason:QString)->int",
    "PySide6.QtQml.qmlRegisterUncreatableType(arg__1:PyTypeObject,arg__2:char*,arg__3:int,arg__4:int,arg__5:char*,arg__6:char*)->int",
    "PySide6.QtQml.qmlTypeId(uri:char*,versionMajor:int,versionMinor:int,qmlName:char*)->int",
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_QtQml()
{
    if (SbkPySide6_QtQmlModuleObject != nullptr)
        return SbkPySide6_QtQmlModuleObject;
    {
        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);
    }

    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("PySide6.QtNetwork"));
        if (requiredModule.isNull())
            return nullptr;
        SbkPySide6_QtNetworkTypes = Shiboken::Module::getTypes(requiredModule);
        SbkPySide6_QtNetworkTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

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

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

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

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

    // Initialize classes in the type system
    init_QQmlTypesExtensionInterface(module);
    init_QQmlScriptString(module);
    init_QQmlPropertyValueSource(module);
    init_QQmlProperty(module);
    init_QQmlParserStatus(module);
    init_QQmlNetworkAccessManagerFactory(module);
    init_QQmlListReference(module);
    init_QQmlIncubator(module);
    init_QQmlIncubationController(module);
    init_QQmlFile(module);
    init_QQmlExtensionInterface(module);
    init_QQmlError(module);
    init_QQmlDebuggingEnabler(module);
    init_QQmlAbstractUrlInterceptor(module);
    init_QJSValueIterator(module);
    init_QJSValue(module);
    init_QJSPrimitiveValue(module);
    init_QJSManagedValue(module);
    init_QQmlPropertyMap(module);
    init_QQmlImageProviderBase(module);
    init_QQmlFileSelector(module);
    init_QQmlExtensionPlugin(module);
    init_QQmlExpression(module);
    init_QQmlContext(module);
    init_QQmlComponent(module);
    init_QJSEngine(module);
    init_QQmlEngine(module);
    init_QQmlApplicationEngine(module);

    // Register converter for type 'QList<QQmlError>'.
    SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLERROR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QQmlError__CppToPython__QList_QQmlError_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLERROR_IDX], "QList<QQmlError>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLERROR_IDX],
        _QList_QQmlError__PythonToCpp__QList_QQmlError_,
        is__QList_QQmlError__PythonToCpp__QList_QQmlError__Convertible);

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

    // Register converter for type 'QHash<QString,QVariant>'.
    SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QHASH_QSTRING_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_QString_QVariant__CppToPython__QHash_QString_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QHASH_QSTRING_QVARIANT_IDX], "QHash<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QHASH_QSTRING_QVARIANT_IDX],
        _QHash_QString_QVariant__PythonToCpp__QHash_QString_QVariant_,
        is__QHash_QString_QVariant__PythonToCpp__QHash_QString_QVariant__Convertible);

    // Register converter for type 'QList<QJSValue>'.
    SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QJSVALUE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QJSValue__CppToPython__QList_QJSValue_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QJSVALUE_IDX], "QList<QJSValue>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QJSVALUE_IDX],
        _QList_QJSValue__PythonToCpp__QList_QJSValue_,
        is__QList_QJSValue__PythonToCpp__QList_QJSValue__Convertible);

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

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

    // Register converter for type 'QList<QQmlAbstractUrlInterceptor*>'.
    SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLABSTRACTURLINTERCEPTORPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QQmlAbstractUrlInterceptorPTR__CppToPython__QList_QQmlAbstractUrlInterceptorPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLABSTRACTURLINTERCEPTORPTR_IDX], "QList<QQmlAbstractUrlInterceptor*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtQmlTypeConverters[SBK_QTQML_QLIST_QQMLABSTRACTURLINTERCEPTORPTR_IDX],
        _QList_QQmlAbstractUrlInterceptorPTR__PythonToCpp__QList_QQmlAbstractUrlInterceptorPTR_,
        is__QList_QQmlAbstractUrlInterceptorPTR__PythonToCpp__QList_QQmlAbstractUrlInterceptorPTR__Convertible);

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

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

    // Initialization of enums.

    // Initialization of anonymous enum identified by enum value 'QML_HAS_ATTACHED_PROPERTIES'.
    if (PyModule_AddIntConstant(module, "QML_HAS_ATTACHED_PROPERTIES", (long) QML_HAS_ATTACHED_PROPERTIES) < 0)
        return nullptr;
    // End of 'QML_HAS_ATTACHED_PROPERTIES' enum.

    // Initialization of enum 'QQmlModuleImportSpecialVersions'.
    SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX] = Shiboken::Enum::createGlobalEnum(module,
        "QQmlModuleImportSpecialVersions",
        "2:PySide6.QtQml.QQmlModuleImportSpecialVersions",
        "QQmlModuleImportSpecialVersions");
    if (!SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX])
        return nullptr;

    if (!Shiboken::Enum::createGlobalEnumItem(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX],
        module, "QQmlModuleImportModuleAny", (long) QQmlModuleImportSpecialVersions::QQmlModuleImportModuleAny))
        return nullptr;
    if (!Shiboken::Enum::createGlobalEnumItem(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX],
        module, "QQmlModuleImportLatest", (long) QQmlModuleImportSpecialVersions::QQmlModuleImportLatest))
        return nullptr;
    if (!Shiboken::Enum::createGlobalEnumItem(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX],
        module, "QQmlModuleImportAuto", (long) QQmlModuleImportSpecialVersions::QQmlModuleImportAuto))
        return nullptr;
    // Register converter for enum 'QQmlModuleImportSpecialVersions'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX],
            QQmlModuleImportSpecialVersions_CppToPython_QQmlModuleImportSpecialVersions);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            QQmlModuleImportSpecialVersions_PythonToCpp_QQmlModuleImportSpecialVersions,
            is_QQmlModuleImportSpecialVersions_PythonToCpp_QQmlModuleImportSpecialVersions_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPySide6_QtQmlTypes[SBK_QQMLMODULEIMPORTSPECIALVERSIONS_IDX], converter, false);
        Shiboken::Conversions::registerConverterName(converter, "QQmlModuleImportSpecialVersions");
    }
    // End of 'QQmlModuleImportSpecialVersions' enum.

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_QtQmlTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_QtQmlTypeConverters);

    if (PyErr_Occurred()) {
        PyErr_Print();
        Py_FatalError("can't initialize module QtQml");
    }
    // Begin code injection
    // ========================================================================
    // START of custom code block [file: ../glue/qtqml.cpp (init)]
    initQtQmlListProperty(module);
    initQmlUncreatable(module);
    initQtQmlVolatileBool(module);
    // END of custom code block [file: ../glue/qtqml.cpp (init)]
    // ========================================================================
    // End of code injection

    qRegisterMetaType< ::QQmlModuleImportSpecialVersions >("QQmlModuleImportSpecialVersions");
    PySide::registerCleanupFunction(cleanTypesAttributes);

    FinishSignatureInitialization(module, QtQml_SignatureStrings);

    return module;
}
