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



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

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

// Classes initialization functions ------------------------------------------------------------
void init_QSslPreSharedKeyAuthenticator(PyObject *module);
void init_QSslError(PyObject *module);
void init_QSslEllipticCurve(PyObject *module);
void init_QSslDiffieHellmanParameters(PyObject *module);
void init_QSslConfiguration(PyObject *module);
void init_QSslConfigurationStaticFields();
void init_QSslCipher(PyObject *module);
void init_QSslCertificateExtension(PyObject *module);
void init_QtNetworkQSsl(PyObject *module);
void init_QtNetworkQPasswordDigestor(PyObject *module);
void init_QOcspResponse(PyObject *module);
void init_QNetworkRequest(PyObject *module);
void init_QNetworkProxyQuery(PyObject *module);
void init_QNetworkProxyFactory(PyObject *module);
void init_QNetworkProxy(PyObject *module);
void init_QNetworkInterface(PyObject *module);
void init_QNetworkCacheMetaData(PyObject *module);
void init_QNetworkAddressEntry(PyObject *module);
void init_QIPv6Address(PyObject *module);
void init_QHttpPart(PyObject *module);
void init_QHttp2Configuration(PyObject *module);
void init_QHstsPolicy(PyObject *module);
void init_QHostInfo(PyObject *module);
void init_QDnsTextRecord(PyObject *module);
void init_QDnsServiceRecord(PyObject *module);
void init_QDnsMailExchangeRecord(PyObject *module);
void init_QDnsHostAddressRecord(PyObject *module);
void init_QDnsDomainNameRecord(PyObject *module);
void init_QAuthenticator(PyObject *module);
void init_QNetworkInformation(PyObject *module);
void init_QNetworkCookieJar(PyObject *module);
void init_QNetworkAccessManager(PyObject *module);
void init_QLocalServer(PyObject *module);
void init_QHttpMultiPart(PyObject *module);
void init_QDtlsClientVerifier(PyObject *module);
void init_QDnsLookup(PyObject *module);
void init_QAbstractNetworkCache(PyObject *module);
void init_QNetworkDiskCache(PyObject *module);
void init_QNetworkReply(PyObject *module);
void init_QLocalSocket(PyObject *module);
void init_QAbstractSocket(PyObject *module);
void init_QUdpSocket(PyObject *module);
void init_QTcpSocket(PyObject *module);
void init_QHostAddress(PyObject *module);
void init_QHostAddressStaticFields();
void init_QTcpServer(PyObject *module);
void init_QNetworkDatagram(PyObject *module);
void init_QSslSocket(PyObject *module);
void init_QSslKey(PyObject *module);
void init_QSslCertificate(PyObject *module);
void init_QNetworkCookie(PyObject *module);
void init_QDtls(PyObject *module);

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

}
static PythonToCppFunc is_QDtlsError_PythonToCpp_QDtlsError_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX]))
        return QDtlsError_PythonToCpp_QDtlsError;
    return {};
}
static PyObject *QDtlsError_CppToPython_QDtlsError(const void *cppIn)
{
    const int castCppIn = int(*reinterpret_cast<const ::QDtlsError *>(cppIn));
    return Shiboken::Enum::newItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], castCppIn);

}


static void QOcspCertificateStatus_PythonToCpp_QOcspCertificateStatus(PyObject *pyIn, void *cppOut)
{
    *reinterpret_cast<::QOcspCertificateStatus *>(cppOut) =
        static_cast<::QOcspCertificateStatus>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_QOcspCertificateStatus_PythonToCpp_QOcspCertificateStatus_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX]))
        return QOcspCertificateStatus_PythonToCpp_QOcspCertificateStatus;
    return {};
}
static PyObject *QOcspCertificateStatus_CppToPython_QOcspCertificateStatus(const void *cppIn)
{
    const int castCppIn = int(*reinterpret_cast<const ::QOcspCertificateStatus *>(cppIn));
    return Shiboken::Enum::newItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX], castCppIn);

}


static void QOcspRevocationReason_PythonToCpp_QOcspRevocationReason(PyObject *pyIn, void *cppOut)
{
    *reinterpret_cast<::QOcspRevocationReason *>(cppOut) =
        static_cast<::QOcspRevocationReason>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_QOcspRevocationReason_PythonToCpp_QOcspRevocationReason_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX]))
        return QOcspRevocationReason_PythonToCpp_QOcspRevocationReason;
    return {};
}
static PyObject *QOcspRevocationReason_CppToPython_QOcspRevocationReason(const void *cppIn)
{
    const int castCppIn = int(*reinterpret_cast<const ::QOcspRevocationReason *>(cppIn));
    return Shiboken::Enum::newItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], castCppIn);

}



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

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

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

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

}
static PythonToCppFunc is__QList_QSslCertificate__PythonToCpp__QList_QSslCertificate__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QSSLCERTIFICATE_IDX], pyIn))
        return _QList_QSslCertificate__PythonToCpp__QList_QSslCertificate_;
    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 'QMap<QByteArray,QVariant >'.
static PyObject *_QMap_QByteArray_QVariant__CppToPython__QMap_QByteArray_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QByteArray,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_QtCoreTypes[SBK_QBYTEARRAY_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_QByteArray_QVariant__PythonToCpp__QMap_QByteArray_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<QByteArray,QVariant > *>(cppOut);
    // TEMPLATE - pydict_to_cppmap_conversion - START
    PyObject *key;
    PyObject *value;
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        ::QByteArray cppKey;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_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_QByteArray_QVariant__PythonToCpp__QMap_QByteArray_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX]))->converter, false, SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], false, pyIn))
        return _QMap_QByteArray_QVariant__PythonToCpp__QMap_QByteArray_QVariant_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QSslCipher__PythonToCpp__QList_QSslCipher__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QSSLCIPHER_IDX], pyIn))
        return _QList_QSslCipher__PythonToCpp__QList_QSslCipher_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QSslEllipticCurve__PythonToCpp__QList_QSslEllipticCurve__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QSSLELLIPTICCURVE_IDX], pyIn))
        return _QList_QSslEllipticCurve__PythonToCpp__QList_QSslEllipticCurve_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QNetworkProxy__PythonToCpp__QList_QNetworkProxy__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QNETWORKPROXY_IDX], pyIn))
        return _QList_QNetworkProxy__PythonToCpp__QList_QNetworkProxy_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QNetworkAddressEntry__PythonToCpp__QList_QNetworkAddressEntry__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QNETWORKADDRESSENTRY_IDX], pyIn))
        return _QList_QNetworkAddressEntry__PythonToCpp__QList_QNetworkAddressEntry_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QHostAddress__PythonToCpp__QList_QHostAddress__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QHOSTADDRESS_IDX], pyIn))
        return _QList_QHostAddress__PythonToCpp__QList_QHostAddress_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QNetworkInterface__PythonToCpp__QList_QNetworkInterface__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QNETWORKINTERFACE_IDX], pyIn))
        return _QList_QNetworkInterface__PythonToCpp__QList_QNetworkInterface_;
    return {};
}

// C++ to Python conversion for container type 'QHash<QNetworkRequest::Attribute,QVariant >'.
static PyObject *_QHash_QNetworkRequest_Attribute_QVariant__CppToPython__QHash_QNetworkRequest_Attribute_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QHash<QNetworkRequest::Attribute,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(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QNETWORKREQUEST_ATTRIBUTE_IDX]))->converter, &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_QNetworkRequest_Attribute_QVariant__PythonToCpp__QHash_QNetworkRequest_Attribute_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QHash<QNetworkRequest::Attribute,QVariant > *>(cppOut);
    // TEMPLATE - pydict_to_cppmap_conversion - START
    PyObject *key;
    PyObject *value;
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        ::QNetworkRequest::Attribute cppKey{QNetworkRequest::HttpStatusCodeAttribute};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QNETWORKREQUEST_ATTRIBUTE_IDX]))->converter, 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_QNetworkRequest_Attribute_QVariant__PythonToCpp__QHash_QNetworkRequest_Attribute_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QNETWORKREQUEST_ATTRIBUTE_IDX]))->converter, false, SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], false, pyIn))
        return _QHash_QNetworkRequest_Attribute_QVariant__PythonToCpp__QHash_QNetworkRequest_Attribute_QVariant_;
    return {};
}

// C++ to Python conversion for container type 'std::pair<QByteArray,QByteArray >'.
static PyObject *_std_pair_QByteArray_QByteArray__CppToPython__std_pair_QByteArray_QByteArray_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::std::pair<QByteArray,QByteArray > *>(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(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], &cppInRef.first));
    PyTuple_SET_ITEM(pyOut, 1, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], &cppInRef.second));
    return pyOut;
    // END of custom code block [file: ../glue/qtcore.cpp (return-qpair)]
    // ========================================================================

}
static void _std_pair_QByteArray_QByteArray__PythonToCpp__std_pair_QByteArray_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::std::pair<QByteArray,QByteArray > *>(cppOut);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], PySequence_Fast_GET_ITEM(pyIn, 0), &(cppOutRef.first));
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_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_QByteArray_QByteArray__PythonToCpp__std_pair_QByteArray_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertiblePairTypes(PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX]))->converter, false, PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX]))->converter, false, pyIn))
        return _std_pair_QByteArray_QByteArray__PythonToCpp__std_pair_QByteArray_QByteArray_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_std_pair_QByteArray_QByteArray___PythonToCpp__QList_std_pair_QByteArray_QByteArray___Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX], pyIn))
        return _QList_std_pair_QByteArray_QByteArray___PythonToCpp__QList_std_pair_QByteArray_QByteArray__;
    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<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<QNetworkCookie >'.
static PyObject *_QList_QNetworkCookie__CppToPython__QList_QNetworkCookie_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QNetworkCookie > *>(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_QtNetworkTypes[SBK_QNETWORKCOOKIE_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

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

}
static PythonToCppFunc is__QList_QNetworkCookie__PythonToCpp__QList_QNetworkCookie__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QNETWORKCOOKIE_IDX], pyIn))
        return _QList_QNetworkCookie__PythonToCpp__QList_QNetworkCookie_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QHstsPolicy__PythonToCpp__QList_QHstsPolicy__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QHSTSPOLICY_IDX], pyIn))
        return _QList_QHstsPolicy__PythonToCpp__QList_QHstsPolicy_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QSslError__PythonToCpp__QList_QSslError__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QSSLERROR_IDX], pyIn))
        return _QList_QSslError__PythonToCpp__QList_QSslError_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QDnsDomainNameRecord__PythonToCpp__QList_QDnsDomainNameRecord__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QDNSDOMAINNAMERECORD_IDX], pyIn))
        return _QList_QDnsDomainNameRecord__PythonToCpp__QList_QDnsDomainNameRecord_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QDnsHostAddressRecord__PythonToCpp__QList_QDnsHostAddressRecord__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QDNSHOSTADDRESSRECORD_IDX], pyIn))
        return _QList_QDnsHostAddressRecord__PythonToCpp__QList_QDnsHostAddressRecord_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QDnsMailExchangeRecord__PythonToCpp__QList_QDnsMailExchangeRecord__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QDNSMAILEXCHANGERECORD_IDX], pyIn))
        return _QList_QDnsMailExchangeRecord__PythonToCpp__QList_QDnsMailExchangeRecord_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QDnsServiceRecord__PythonToCpp__QList_QDnsServiceRecord__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QDNSSERVICERECORD_IDX], pyIn))
        return _QList_QDnsServiceRecord__PythonToCpp__QList_QDnsServiceRecord_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QDnsTextRecord__PythonToCpp__QList_QDnsTextRecord__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QDNSTEXTRECORD_IDX], pyIn))
        return _QList_QDnsTextRecord__PythonToCpp__QList_QDnsTextRecord_;
    return {};
}

// C++ to Python conversion for container type 'QPair<QHostAddress,int >'.
static PyObject *_QPair_QHostAddress_int__CppToPython__QPair_QHostAddress_int_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QPair<QHostAddress,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(SbkPySide6_QtNetworkTypes[SBK_QHOSTADDRESS_IDX], &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_QHostAddress_int__PythonToCpp__QPair_QHostAddress_int_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QPair<QHostAddress,int > *>(cppOut);
    // ========================================================================
    // START of custom code block [file: ../glue/qtcore.cpp (conversion-qpair-pysequence)]
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtNetworkTypes[SBK_QHOSTADDRESS_IDX], 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_QHostAddress_int__PythonToCpp__QPair_QHostAddress_int__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertiblePairTypes(PepType_SOTP(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtNetworkTypes[SBK_QHOSTADDRESS_IDX]))->converter, false, Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, pyIn))
        return _QPair_QHostAddress_int__PythonToCpp__QPair_QHostAddress_int_;
    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 'QList<QSsl::ImplementedClass >'.
static PyObject *_QList_QSsl_ImplementedClass__CppToPython__QList_QSsl_ImplementedClass_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QSsl::ImplementedClass > *>(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_QtNetworkTypes[SBK_QSSL_IMPLEMENTEDCLASS_IDX]))->converter, &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QSsl_ImplementedClass__PythonToCpp__QList_QSsl_ImplementedClass_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QSsl::ImplementedClass > *>(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;
        }
        ::QSsl::ImplementedClass cppItem{QSsl::ImplementedClass::Key};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_IMPLEMENTEDCLASS_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QSsl_ImplementedClass__PythonToCpp__QList_QSsl_ImplementedClass__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_IMPLEMENTEDCLASS_IDX]))->converter, pyIn))
        return _QList_QSsl_ImplementedClass__PythonToCpp__QList_QSsl_ImplementedClass_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QOcspResponse__PythonToCpp__QList_QOcspResponse__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QOCSPRESPONSE_IDX], pyIn))
        return _QList_QOcspResponse__PythonToCpp__QList_QOcspResponse_;
    return {};
}

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

}
static void _QList_QSsl_SupportedFeature__PythonToCpp__QList_QSsl_SupportedFeature_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QSsl::SupportedFeature > *>(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;
        }
        ::QSsl::SupportedFeature cppItem{QSsl::SupportedFeature::CertificateVerification};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_SUPPORTEDFEATURE_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QSsl_SupportedFeature__PythonToCpp__QList_QSsl_SupportedFeature__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_SUPPORTEDFEATURE_IDX]))->converter, pyIn))
        return _QList_QSsl_SupportedFeature__PythonToCpp__QList_QSsl_SupportedFeature_;
    return {};
}

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

}
static void _QList_QSsl_SslProtocol__PythonToCpp__QList_QSsl_SslProtocol_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QSsl::SslProtocol > *>(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;
        }
        ::QSsl::SslProtocol cppItem{QSsl::TlsV1_0};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_SSLPROTOCOL_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QSsl_SslProtocol__PythonToCpp__QList_QSsl_SslProtocol__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_SSLPROTOCOL_IDX]))->converter, pyIn))
        return _QList_QSsl_SslProtocol__PythonToCpp__QList_QSsl_SslProtocol_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QSslCertificateExtension__PythonToCpp__QList_QSslCertificateExtension__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtNetworkTypes[SBK_QSSLCERTIFICATEEXTENSION_IDX], pyIn))
        return _QList_QSslCertificateExtension__PythonToCpp__QList_QSslCertificateExtension_;
    return {};
}

// C++ to Python conversion for container type 'QMultiMap<QSsl::AlternativeNameEntryType,QString >'.
static PyObject *_QMultiMap_QSsl_AlternativeNameEntryType_QString__CppToPython__QMultiMap_QSsl_AlternativeNameEntryType_QString_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMultiMap<QSsl::AlternativeNameEntryType,QString > *>(cppIn);
    // TEMPLATE - cppmultimap_to_pymap_conversion - START
    PyObject *pyOut = PyDict_New();
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ) {
        const auto &key = it.key();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_ALTERNATIVENAMEENTRYTYPE_IDX]))->converter, &key);
        ::QMultiMap<QSsl::AlternativeNameEntryType,QString >::const_iterator keyEnd = cppInRef.upperBound(key);
        const auto count = Py_ssize_t(std::distance(it, keyEnd));
        PyObject *pyValues = PyList_New(count);
        Py_ssize_t idx = 0;
        for ( ; it != keyEnd; ++it, ++idx) {
            const auto &cppItem = it.value();
            PyList_SET_ITEM(pyValues, idx, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], &cppItem));
        }
        PyDict_SetItem(pyOut, pyKey, pyValues);
        Py_DECREF(pyKey);
    }
    return pyOut;
    // TEMPLATE - cppmultimap_to_pymap_conversion - END

}
static void _QMultiMap_QSsl_AlternativeNameEntryType_QString__PythonToCpp__QMultiMap_QSsl_AlternativeNameEntryType_QString_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMultiMap<QSsl::AlternativeNameEntryType,QString > *>(cppOut);
    // TEMPLATE - pydict_to_cppmultimap_conversion - START
    PyObject *key;
    PyObject *values;
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &values)) {
        ::QSsl::AlternativeNameEntryType cppKey{QSsl::EmailEntry};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_ALTERNATIVENAMEENTRYTYPE_IDX]))->converter, key, &(cppKey));
        const Py_ssize_t size = PySequence_Size(values);
        for (Py_ssize_t i = 0; i < size; ++i) {
            Shiboken::AutoDecRef value(PySequence_GetItem(values, i));
            ::QString cppValue;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], value, &(cppValue));
            cppOutRef.insert(cppKey, cppValue);
        }
    }
    // TEMPLATE - pydict_to_cppmultimap_conversion - END

}
static PythonToCppFunc is__QMultiMap_QSsl_AlternativeNameEntryType_QString__PythonToCpp__QMultiMap_QSsl_AlternativeNameEntryType_QString__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleMultiDictTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtNetworkTypes[SBK_QSSL_ALTERNATIVENAMEENTRYTYPE_IDX]))->converter, false, SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], false, pyIn))
        return _QMultiMap_QSsl_AlternativeNameEntryType_QString__PythonToCpp__QMultiMap_QSsl_AlternativeNameEntryType_QString_;
    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 '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     */ "QtNetwork",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ QtNetwork_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 *QtNetwork_SignatureStrings[] = {
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_QtNetwork()
{
    if (SbkPySide6_QtNetworkModuleObject != nullptr)
        return SbkPySide6_QtNetworkModuleObject;
    {
        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_QtNetwork_IDX_COUNT];
    SbkPySide6_QtNetworkTypes = cppApi;

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

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

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

    // Initialize classes in the type system
    init_QSslPreSharedKeyAuthenticator(module);
    init_QSslError(module);
    init_QSslEllipticCurve(module);
    init_QSslDiffieHellmanParameters(module);
    init_QSslConfiguration(module);
    init_QSslCipher(module);
    init_QSslCertificateExtension(module);
    init_QtNetworkQSsl(module);
    init_QtNetworkQPasswordDigestor(module);
    init_QOcspResponse(module);
    init_QNetworkRequest(module);
    init_QNetworkProxyQuery(module);
    init_QNetworkProxyFactory(module);
    init_QNetworkProxy(module);
    init_QNetworkInterface(module);
    init_QNetworkCacheMetaData(module);
    init_QNetworkAddressEntry(module);
    init_QIPv6Address(module);
    init_QHttpPart(module);
    init_QHttp2Configuration(module);
    init_QHstsPolicy(module);
    init_QHostInfo(module);
    init_QDnsTextRecord(module);
    init_QDnsServiceRecord(module);
    init_QDnsMailExchangeRecord(module);
    init_QDnsHostAddressRecord(module);
    init_QDnsDomainNameRecord(module);
    init_QAuthenticator(module);
    init_QNetworkInformation(module);
    init_QNetworkCookieJar(module);
    init_QNetworkAccessManager(module);
    init_QLocalServer(module);
    init_QHttpMultiPart(module);
    init_QDtlsClientVerifier(module);
    init_QDnsLookup(module);
    init_QAbstractNetworkCache(module);
    init_QNetworkDiskCache(module);
    init_QNetworkReply(module);
    init_QLocalSocket(module);
    init_QAbstractSocket(module);
    init_QUdpSocket(module);
    init_QTcpSocket(module);
    init_QHostAddress(module);
    init_QTcpServer(module);
    init_QNetworkDatagram(module);
    init_QSslSocket(module);
    init_QSslKey(module);
    init_QSslCertificate(module);
    init_QNetworkCookie(module);
    init_QDtls(module);

    // Register converter for type 'QList<QSslCertificate>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSslCertificate__CppToPython__QList_QSslCertificate_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATE_IDX], "QList<QSslCertificate>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATE_IDX],
        _QList_QSslCertificate__PythonToCpp__QList_QSslCertificate_,
        is__QList_QSslCertificate__PythonToCpp__QList_QSslCertificate__Convertible);

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

    // Register converter for type 'QMap<QByteArray,QVariant>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMAP_QBYTEARRAY_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QByteArray_QVariant__CppToPython__QMap_QByteArray_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMAP_QBYTEARRAY_QVARIANT_IDX], "QMap<QByteArray,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMAP_QBYTEARRAY_QVARIANT_IDX],
        _QMap_QByteArray_QVariant__PythonToCpp__QMap_QByteArray_QVariant_,
        is__QMap_QByteArray_QVariant__PythonToCpp__QMap_QByteArray_QVariant__Convertible);

    // Register converter for type 'QList<QSslCipher>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCIPHER_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSslCipher__CppToPython__QList_QSslCipher_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCIPHER_IDX], "QList<QSslCipher>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCIPHER_IDX],
        _QList_QSslCipher__PythonToCpp__QList_QSslCipher_,
        is__QList_QSslCipher__PythonToCpp__QList_QSslCipher__Convertible);

    // Register converter for type 'QList<QSslEllipticCurve>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLELLIPTICCURVE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSslEllipticCurve__CppToPython__QList_QSslEllipticCurve_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLELLIPTICCURVE_IDX], "QList<QSslEllipticCurve>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLELLIPTICCURVE_IDX],
        _QList_QSslEllipticCurve__PythonToCpp__QList_QSslEllipticCurve_,
        is__QList_QSslEllipticCurve__PythonToCpp__QList_QSslEllipticCurve__Convertible);

    // Register converter for type 'QList<QNetworkProxy>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKPROXY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QNetworkProxy__CppToPython__QList_QNetworkProxy_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKPROXY_IDX], "QList<QNetworkProxy>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKPROXY_IDX],
        _QList_QNetworkProxy__PythonToCpp__QList_QNetworkProxy_,
        is__QList_QNetworkProxy__PythonToCpp__QList_QNetworkProxy__Convertible);

    // Register converter for type 'QList<QNetworkAddressEntry>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKADDRESSENTRY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QNetworkAddressEntry__CppToPython__QList_QNetworkAddressEntry_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKADDRESSENTRY_IDX], "QList<QNetworkAddressEntry>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKADDRESSENTRY_IDX],
        _QList_QNetworkAddressEntry__PythonToCpp__QList_QNetworkAddressEntry_,
        is__QList_QNetworkAddressEntry__PythonToCpp__QList_QNetworkAddressEntry__Convertible);

    // Register converter for type 'QList<QHostAddress>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHOSTADDRESS_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QHostAddress__CppToPython__QList_QHostAddress_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHOSTADDRESS_IDX], "QList<QHostAddress>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHOSTADDRESS_IDX],
        _QList_QHostAddress__PythonToCpp__QList_QHostAddress_,
        is__QList_QHostAddress__PythonToCpp__QList_QHostAddress__Convertible);

    // Register converter for type 'QList<QNetworkInterface>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKINTERFACE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QNetworkInterface__CppToPython__QList_QNetworkInterface_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKINTERFACE_IDX], "QList<QNetworkInterface>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKINTERFACE_IDX],
        _QList_QNetworkInterface__PythonToCpp__QList_QNetworkInterface_,
        is__QList_QNetworkInterface__PythonToCpp__QList_QNetworkInterface__Convertible);

    // Register converter for type 'QHash<QNetworkRequest::Attribute,QVariant>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QHASH_QNETWORKREQUEST_ATTRIBUTE_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_QNetworkRequest_Attribute_QVariant__CppToPython__QHash_QNetworkRequest_Attribute_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QHASH_QNETWORKREQUEST_ATTRIBUTE_QVARIANT_IDX], "QHash<QNetworkRequest::Attribute,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QHASH_QNETWORKREQUEST_ATTRIBUTE_QVARIANT_IDX],
        _QHash_QNetworkRequest_Attribute_QVariant__PythonToCpp__QHash_QNetworkRequest_Attribute_QVariant_,
        is__QHash_QNetworkRequest_Attribute_QVariant__PythonToCpp__QHash_QNetworkRequest_Attribute_QVariant__Convertible);

    // Register converter for type 'std::pair<QByteArray,QByteArray>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _std_pair_QByteArray_QByteArray__CppToPython__std_pair_QByteArray_QByteArray_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX], "std::pair<QByteArray,QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX],
        _std_pair_QByteArray_QByteArray__PythonToCpp__std_pair_QByteArray_QByteArray_,
        is__std_pair_QByteArray_QByteArray__PythonToCpp__std_pair_QByteArray_QByteArray__Convertible);

    // Register converter for type 'QList<std::pair<QByteArray,QByteArray>>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_std_pair_QByteArray_QByteArray___CppToPython__QList_std_pair_QByteArray_QByteArray__);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX], "QList<std::pair<QByteArray,QByteArray>>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_STD_PAIR_QBYTEARRAY_QBYTEARRAY_IDX],
        _QList_std_pair_QByteArray_QByteArray___PythonToCpp__QList_std_pair_QByteArray_QByteArray__,
        is__QList_std_pair_QByteArray_QByteArray___PythonToCpp__QList_std_pair_QByteArray_QByteArray___Convertible);

    // Register converter for type 'QHash<QString,QVariant>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QHASH_QSTRING_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_QString_QVariant__CppToPython__QHash_QString_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QHASH_QSTRING_QVARIANT_IDX], "QHash<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_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<QObject*>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOBJECTPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QObjectPTR__CppToPython__QList_QObjectPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOBJECTPTR_IDX], "QList<QObject*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOBJECTPTR_IDX],
        _QList_QObjectPTR__PythonToCpp__QList_QObjectPTR_,
        is__QList_QObjectPTR__PythonToCpp__QList_QObjectPTR__Convertible);

    // Register converter for type 'QList<QNetworkCookie>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKCOOKIE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QNetworkCookie__CppToPython__QList_QNetworkCookie_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKCOOKIE_IDX], "QList<QNetworkCookie>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QNETWORKCOOKIE_IDX],
        _QList_QNetworkCookie__PythonToCpp__QList_QNetworkCookie_,
        is__QList_QNetworkCookie__PythonToCpp__QList_QNetworkCookie__Convertible);

    // Register converter for type 'QList<QHstsPolicy>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHSTSPOLICY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QHstsPolicy__CppToPython__QList_QHstsPolicy_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHSTSPOLICY_IDX], "QList<QHstsPolicy>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QHSTSPOLICY_IDX],
        _QList_QHstsPolicy__PythonToCpp__QList_QHstsPolicy_,
        is__QList_QHstsPolicy__PythonToCpp__QList_QHstsPolicy__Convertible);

    // Register converter for type 'QList<QSslError>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLERROR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSslError__CppToPython__QList_QSslError_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLERROR_IDX], "QList<QSslError>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLERROR_IDX],
        _QList_QSslError__PythonToCpp__QList_QSslError_,
        is__QList_QSslError__PythonToCpp__QList_QSslError__Convertible);

    // Register converter for type 'QList<QDnsDomainNameRecord>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSDOMAINNAMERECORD_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDnsDomainNameRecord__CppToPython__QList_QDnsDomainNameRecord_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSDOMAINNAMERECORD_IDX], "QList<QDnsDomainNameRecord>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSDOMAINNAMERECORD_IDX],
        _QList_QDnsDomainNameRecord__PythonToCpp__QList_QDnsDomainNameRecord_,
        is__QList_QDnsDomainNameRecord__PythonToCpp__QList_QDnsDomainNameRecord__Convertible);

    // Register converter for type 'QList<QDnsHostAddressRecord>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSHOSTADDRESSRECORD_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDnsHostAddressRecord__CppToPython__QList_QDnsHostAddressRecord_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSHOSTADDRESSRECORD_IDX], "QList<QDnsHostAddressRecord>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSHOSTADDRESSRECORD_IDX],
        _QList_QDnsHostAddressRecord__PythonToCpp__QList_QDnsHostAddressRecord_,
        is__QList_QDnsHostAddressRecord__PythonToCpp__QList_QDnsHostAddressRecord__Convertible);

    // Register converter for type 'QList<QDnsMailExchangeRecord>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSMAILEXCHANGERECORD_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDnsMailExchangeRecord__CppToPython__QList_QDnsMailExchangeRecord_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSMAILEXCHANGERECORD_IDX], "QList<QDnsMailExchangeRecord>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSMAILEXCHANGERECORD_IDX],
        _QList_QDnsMailExchangeRecord__PythonToCpp__QList_QDnsMailExchangeRecord_,
        is__QList_QDnsMailExchangeRecord__PythonToCpp__QList_QDnsMailExchangeRecord__Convertible);

    // Register converter for type 'QList<QDnsServiceRecord>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSSERVICERECORD_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDnsServiceRecord__CppToPython__QList_QDnsServiceRecord_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSSERVICERECORD_IDX], "QList<QDnsServiceRecord>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSSERVICERECORD_IDX],
        _QList_QDnsServiceRecord__PythonToCpp__QList_QDnsServiceRecord_,
        is__QList_QDnsServiceRecord__PythonToCpp__QList_QDnsServiceRecord__Convertible);

    // Register converter for type 'QList<QDnsTextRecord>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSTEXTRECORD_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDnsTextRecord__CppToPython__QList_QDnsTextRecord_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSTEXTRECORD_IDX], "QList<QDnsTextRecord>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QDNSTEXTRECORD_IDX],
        _QList_QDnsTextRecord__PythonToCpp__QList_QDnsTextRecord_,
        is__QList_QDnsTextRecord__PythonToCpp__QList_QDnsTextRecord__Convertible);

    // Register converter for type 'QPair<QHostAddress,int>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QPAIR_QHOSTADDRESS_INT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QPair_QHostAddress_int__CppToPython__QPair_QHostAddress_int_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QPAIR_QHOSTADDRESS_INT_IDX], "QPair<QHostAddress,int>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QPAIR_QHOSTADDRESS_INT_IDX],
        _QPair_QHostAddress_int__PythonToCpp__QPair_QHostAddress_int_,
        is__QPair_QHostAddress_int__PythonToCpp__QPair_QHostAddress_int__Convertible);

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

    // Register converter for type 'QList<QSsl::ImplementedClass>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_IMPLEMENTEDCLASS_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSsl_ImplementedClass__CppToPython__QList_QSsl_ImplementedClass_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_IMPLEMENTEDCLASS_IDX], "QList<QSsl::ImplementedClass>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_IMPLEMENTEDCLASS_IDX],
        _QList_QSsl_ImplementedClass__PythonToCpp__QList_QSsl_ImplementedClass_,
        is__QList_QSsl_ImplementedClass__PythonToCpp__QList_QSsl_ImplementedClass__Convertible);

    // Register converter for type 'QList<QOcspResponse>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOCSPRESPONSE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QOcspResponse__CppToPython__QList_QOcspResponse_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOCSPRESPONSE_IDX], "QList<QOcspResponse>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QOCSPRESPONSE_IDX],
        _QList_QOcspResponse__PythonToCpp__QList_QOcspResponse_,
        is__QList_QOcspResponse__PythonToCpp__QList_QOcspResponse__Convertible);

    // Register converter for type 'QList<QSsl::SupportedFeature>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SUPPORTEDFEATURE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSsl_SupportedFeature__CppToPython__QList_QSsl_SupportedFeature_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SUPPORTEDFEATURE_IDX], "QList<QSsl::SupportedFeature>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SUPPORTEDFEATURE_IDX],
        _QList_QSsl_SupportedFeature__PythonToCpp__QList_QSsl_SupportedFeature_,
        is__QList_QSsl_SupportedFeature__PythonToCpp__QList_QSsl_SupportedFeature__Convertible);

    // Register converter for type 'QList<QSsl::SslProtocol>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SSLPROTOCOL_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSsl_SslProtocol__CppToPython__QList_QSsl_SslProtocol_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SSLPROTOCOL_IDX], "QList<QSsl::SslProtocol>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSL_SSLPROTOCOL_IDX],
        _QList_QSsl_SslProtocol__PythonToCpp__QList_QSsl_SslProtocol_,
        is__QList_QSsl_SslProtocol__PythonToCpp__QList_QSsl_SslProtocol__Convertible);

    // Register converter for type 'QList<QSslCertificateExtension>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATEEXTENSION_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QSslCertificateExtension__CppToPython__QList_QSslCertificateExtension_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATEEXTENSION_IDX], "QList<QSslCertificateExtension>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QLIST_QSSLCERTIFICATEEXTENSION_IDX],
        _QList_QSslCertificateExtension__PythonToCpp__QList_QSslCertificateExtension_,
        is__QList_QSslCertificateExtension__PythonToCpp__QList_QSslCertificateExtension__Convertible);

    // Register converter for type 'QMultiMap<QSsl::AlternativeNameEntryType,QString>'.
    SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMULTIMAP_QSSL_ALTERNATIVENAMEENTRYTYPE_QSTRING_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMultiMap_QSsl_AlternativeNameEntryType_QString__CppToPython__QMultiMap_QSsl_AlternativeNameEntryType_QString_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMULTIMAP_QSSL_ALTERNATIVENAMEENTRYTYPE_QSTRING_IDX], "QMultiMap<QSsl::AlternativeNameEntryType,QString>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtNetworkTypeConverters[SBK_QTNETWORK_QMULTIMAP_QSSL_ALTERNATIVENAMEENTRYTYPE_QSTRING_IDX],
        _QMultiMap_QSsl_AlternativeNameEntryType_QString__PythonToCpp__QMultiMap_QSsl_AlternativeNameEntryType_QString_,
        is__QMultiMap_QSsl_AlternativeNameEntryType_QString__PythonToCpp__QMultiMap_QSsl_AlternativeNameEntryType_QString__Convertible);

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

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

    // Initialization of enums.

    // Initialization of enum 'QDtlsError'.
    SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX] = Shiboken::Enum::createGlobalEnum(module,
        "QDtlsError",
        "2:PySide6.QtNetwork.QDtlsError",
        "QDtlsError");
    if (!SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX])
        return nullptr;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "NoError", (long) QDtlsError::NoError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "InvalidInputParameters", (long) QDtlsError::InvalidInputParameters))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "InvalidOperation", (long) QDtlsError::InvalidOperation))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "UnderlyingSocketError", (long) QDtlsError::UnderlyingSocketError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "RemoteClosedConnectionError", (long) QDtlsError::RemoteClosedConnectionError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "PeerVerificationError", (long) QDtlsError::PeerVerificationError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "TlsInitializationError", (long) QDtlsError::TlsInitializationError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "TlsFatalError", (long) QDtlsError::TlsFatalError))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], "TlsNonFatalError", (long) QDtlsError::TlsNonFatalError))
        return nullptr;
    // Register converter for enum 'QDtlsError'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX],
            QDtlsError_CppToPython_QDtlsError);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            QDtlsError_PythonToCpp_QDtlsError,
            is_QDtlsError_PythonToCpp_QDtlsError_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPySide6_QtNetworkTypes[SBK_QDTLSERROR_IDX], converter, false);
        Shiboken::Conversions::registerConverterName(converter, "QDtlsError");
    }
    // End of 'QDtlsError' enum.

    // Initialization of enum 'QOcspCertificateStatus'.
    SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX] = Shiboken::Enum::createGlobalEnum(module,
        "QOcspCertificateStatus",
        "2:PySide6.QtNetwork.QOcspCertificateStatus",
        "QOcspCertificateStatus");
    if (!SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX])
        return nullptr;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX], "Good", (long) QOcspCertificateStatus::Good))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX], "Revoked", (long) QOcspCertificateStatus::Revoked))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX], "Unknown", (long) QOcspCertificateStatus::Unknown))
        return nullptr;
    // Register converter for enum 'QOcspCertificateStatus'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX],
            QOcspCertificateStatus_CppToPython_QOcspCertificateStatus);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            QOcspCertificateStatus_PythonToCpp_QOcspCertificateStatus,
            is_QOcspCertificateStatus_PythonToCpp_QOcspCertificateStatus_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPySide6_QtNetworkTypes[SBK_QOCSPCERTIFICATESTATUS_IDX], converter, false);
        Shiboken::Conversions::registerConverterName(converter, "QOcspCertificateStatus");
    }
    // End of 'QOcspCertificateStatus' enum.

    // Initialization of enum 'QOcspRevocationReason'.
    SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX] = Shiboken::Enum::createGlobalEnum(module,
        "QOcspRevocationReason",
        "2:PySide6.QtNetwork.QOcspRevocationReason",
        "QOcspRevocationReason");
    if (!SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX])
        return nullptr;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "None_", (long) QOcspRevocationReason::None))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "Unspecified", (long) QOcspRevocationReason::Unspecified))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "KeyCompromise", (long) QOcspRevocationReason::KeyCompromise))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "CACompromise", (long) QOcspRevocationReason::CACompromise))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "AffiliationChanged", (long) QOcspRevocationReason::AffiliationChanged))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "Superseded", (long) QOcspRevocationReason::Superseded))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "CessationOfOperation", (long) QOcspRevocationReason::CessationOfOperation))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "CertificateHold", (long) QOcspRevocationReason::CertificateHold))
        return nullptr;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
        SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], "RemoveFromCRL", (long) QOcspRevocationReason::RemoveFromCRL))
        return nullptr;
    // Register converter for enum 'QOcspRevocationReason'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX],
            QOcspRevocationReason_CppToPython_QOcspRevocationReason);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            QOcspRevocationReason_PythonToCpp_QOcspRevocationReason,
            is_QOcspRevocationReason_PythonToCpp_QOcspRevocationReason_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPySide6_QtNetworkTypes[SBK_QOCSPREVOCATIONREASON_IDX], converter, false);
        Shiboken::Conversions::registerConverterName(converter, "QOcspRevocationReason");
    }
    // End of 'QOcspRevocationReason' enum.

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_QtNetworkTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_QtNetworkTypeConverters);

    // Static field initialization
    init_QSslConfigurationStaticFields();
    init_QHostAddressStaticFields();

    if (PyErr_Occurred()) {
        PyErr_Print();
        Py_FatalError("can't initialize module QtNetwork");
    }
    qRegisterMetaType< ::QDtlsError >("QDtlsError");
    qRegisterMetaType< ::QOcspCertificateStatus >("QOcspCertificateStatus");
    qRegisterMetaType< ::QOcspRevocationReason >("QOcspRevocationReason");
    PySide::registerCleanupFunction(cleanTypesAttributes);

    FinishSignatureInitialization(module, QtNetwork_SignatureStrings);

    return module;
}
