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



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

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

// Classes initialization functions ------------------------------------------------------------
void init_QVideoFrameFormat(PyObject *module);
void init_QVideoFrameFormatStaticFields();
void init_QVideoFrame(PyObject *module);
void init_QMediaTimeRange(PyObject *module);
void init_QMediaTimeRange_Interval(PyObject *enclosingClass);
void init_QMediaMetaData(PyObject *module);
void init_QMediaMetaDataStaticFields();
void init_QMediaFormat(PyObject *module);
void init_QCameraFormat(PyObject *module);
void init_QCameraDevice(PyObject *module);
void init_QAudioFormat(PyObject *module);
void init_QAudioDevice(PyObject *module);
void init_QAudioBuffer(PyObject *module);
void init_QtMultimediaQAudio(PyObject *module);
void init_QVideoSink(PyObject *module);
void init_QSoundEffect(PyObject *module);
void init_QMediaRecorder(PyObject *module);
void init_QMediaDevices(PyObject *module);
void init_QMediaCaptureSession(PyObject *module);
void init_QImageCapture(PyObject *module);
void init_QCamera(PyObject *module);
void init_QAudioSource(PyObject *module);
void init_QAudioSink(PyObject *module);
void init_QAudioOutput(PyObject *module);
void init_QAudioInput(PyObject *module);
void init_QAudioDecoder(PyObject *module);
void init_QMediaPlayer(PyObject *module);

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

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

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

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

}
static PythonToCppFunc is__QList_QMediaTimeRange_Interval__PythonToCpp__QList_QMediaTimeRange_Interval__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtMultimediaTypes[SBK_QMEDIATIMERANGE_INTERVAL_IDX], pyIn))
        return _QList_QMediaTimeRange_Interval__PythonToCpp__QList_QMediaTimeRange_Interval_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QMediaMetaData_Key__PythonToCpp__QList_QMediaMetaData_Key__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAMETADATA_KEY_IDX]))->converter, pyIn))
        return _QList_QMediaMetaData_Key__PythonToCpp__QList_QMediaMetaData_Key_;
    return {};
}

// C++ to Python conversion for container type 'QHash<QMediaMetaData::Key,QVariant >'.
static PyObject *_QHash_QMediaMetaData_Key_QVariant__CppToPython__QHash_QMediaMetaData_Key_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QHash<QMediaMetaData::Key,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_QtMultimediaTypes[SBK_QMEDIAMETADATA_KEY_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_QMediaMetaData_Key_QVariant__PythonToCpp__QHash_QMediaMetaData_Key_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QHash<QMediaMetaData::Key,QVariant > *>(cppOut);
    // TEMPLATE - pydict_to_cppmap_conversion - START
    PyObject *key;
    PyObject *value;
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        ::QMediaMetaData::Key cppKey{QMediaMetaData::Title};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAMETADATA_KEY_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_QMediaMetaData_Key_QVariant__PythonToCpp__QHash_QMediaMetaData_Key_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAMETADATA_KEY_IDX]))->converter, false, SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], false, pyIn))
        return _QHash_QMediaMetaData_Key_QVariant__PythonToCpp__QHash_QMediaMetaData_Key_QVariant_;
    return {};
}

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

}
static void _QList_QMediaFormat_AudioCodec__PythonToCpp__QList_QMediaFormat_AudioCodec_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QMediaFormat::AudioCodec > *>(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;
        }
        ::QMediaFormat::AudioCodec cppItem{QMediaFormat::AudioCodec::MP3};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_AUDIOCODEC_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QMediaFormat_AudioCodec__PythonToCpp__QList_QMediaFormat_AudioCodec__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_AUDIOCODEC_IDX]))->converter, pyIn))
        return _QList_QMediaFormat_AudioCodec__PythonToCpp__QList_QMediaFormat_AudioCodec_;
    return {};
}

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

}
static void _QList_QMediaFormat_FileFormat__PythonToCpp__QList_QMediaFormat_FileFormat_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QMediaFormat::FileFormat > *>(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;
        }
        ::QMediaFormat::FileFormat cppItem{QMediaFormat::WMV};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_FILEFORMAT_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QMediaFormat_FileFormat__PythonToCpp__QList_QMediaFormat_FileFormat__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_FILEFORMAT_IDX]))->converter, pyIn))
        return _QList_QMediaFormat_FileFormat__PythonToCpp__QList_QMediaFormat_FileFormat_;
    return {};
}

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

}
static void _QList_QMediaFormat_VideoCodec__PythonToCpp__QList_QMediaFormat_VideoCodec_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QMediaFormat::VideoCodec > *>(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;
        }
        ::QMediaFormat::VideoCodec cppItem{QMediaFormat::VideoCodec::MPEG1};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_VIDEOCODEC_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QMediaFormat_VideoCodec__PythonToCpp__QList_QMediaFormat_VideoCodec__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAFORMAT_VIDEOCODEC_IDX]))->converter, pyIn))
        return _QList_QMediaFormat_VideoCodec__PythonToCpp__QList_QMediaFormat_VideoCodec_;
    return {};
}

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

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

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

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

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

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

}
static PythonToCppFunc is__QList_QCameraFormat__PythonToCpp__QList_QCameraFormat__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtMultimediaTypes[SBK_QCAMERAFORMAT_IDX], pyIn))
        return _QList_QCameraFormat__PythonToCpp__QList_QCameraFormat_;
    return {};
}

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

}
static void _QList_QAudioFormat_SampleFormat__PythonToCpp__QList_QAudioFormat_SampleFormat_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QAudioFormat::SampleFormat > *>(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;
        }
        ::QAudioFormat::SampleFormat cppItem{QAudioFormat::Unknown};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QAUDIOFORMAT_SAMPLEFORMAT_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QAudioFormat_SampleFormat__PythonToCpp__QList_QAudioFormat_SampleFormat__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QAUDIOFORMAT_SAMPLEFORMAT_IDX]))->converter, pyIn))
        return _QList_QAudioFormat_SampleFormat__PythonToCpp__QList_QAudioFormat_SampleFormat_;
    return {};
}

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

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

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

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

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

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

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

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

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

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

}
static PythonToCppFunc is__QList_QAudioDevice__PythonToCpp__QList_QAudioDevice__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtMultimediaTypes[SBK_QAUDIODEVICE_IDX], pyIn))
        return _QList_QAudioDevice__PythonToCpp__QList_QAudioDevice_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QCameraDevice__PythonToCpp__QList_QCameraDevice__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtMultimediaTypes[SBK_QCAMERADEVICE_IDX], pyIn))
        return _QList_QCameraDevice__PythonToCpp__QList_QCameraDevice_;
    return {};
}

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

}
static void _QList_QImageCapture_FileFormat__PythonToCpp__QList_QImageCapture_FileFormat_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QImageCapture::FileFormat > *>(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;
        }
        ::QImageCapture::FileFormat cppItem{QImageCapture::UnspecifiedFormat};
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QIMAGECAPTURE_FILEFORMAT_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QImageCapture_FileFormat__PythonToCpp__QList_QImageCapture_FileFormat__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_QtMultimediaTypes[SBK_QIMAGECAPTURE_FILEFORMAT_IDX]))->converter, pyIn))
        return _QList_QImageCapture_FileFormat__PythonToCpp__QList_QImageCapture_FileFormat_;
    return {};
}

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

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

}
static PythonToCppFunc is__QList_QMediaMetaData__PythonToCpp__QList_QMediaMetaData__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtMultimediaTypes[SBK_QMEDIAMETADATA_IDX], pyIn))
        return _QList_QMediaMetaData__PythonToCpp__QList_QMediaMetaData_;
    return {};
}

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

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

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

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

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

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

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

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

// C++ to Python conversion for container type 'QMap<QString,QVariant >'.
static PyObject *_QMap_QString_QVariant__CppToPython__QMap_QString_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QString,QVariant > *>(cppIn);
    // TEMPLATE - cppmap_to_pymap_conversion - START
    PyObject *pyOut = PyDict_New();
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it) {
        const auto &key = it.key();
        const auto &value = it.value();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - cppmap_to_pymap_conversion - END

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

}
static PythonToCppFunc is__QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], false, SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], false, pyIn))
        return _QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant_;
    return {};
}


static struct PyModuleDef moduledef = {
    /* m_base     */ PyModuleDef_HEAD_INIT,
    /* m_name     */ "QtMultimedia",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ QtMultimedia_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 *QtMultimedia_SignatureStrings[] = {
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_QtMultimedia()
{
    if (SbkPySide6_QtMultimediaModuleObject != nullptr)
        return SbkPySide6_QtMultimediaModuleObject;
    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("PySide6.QtCore"));
        if (requiredModule.isNull())
            return nullptr;
        SbkPySide6_QtCoreTypes = Shiboken::Module::getTypes(requiredModule);
        SbkPySide6_QtCoreTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

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

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

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

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

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

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

    // Initialize classes in the type system
    init_QVideoFrameFormat(module);
    init_QVideoFrame(module);
    init_QMediaTimeRange(module);
    init_QMediaTimeRange_Interval(reinterpret_cast<PyTypeObject *>(SbkPySide6_QtMultimediaTypes[SBK_QMEDIATIMERANGE_IDX])->tp_dict);
    init_QMediaMetaData(module);
    init_QMediaFormat(module);
    init_QCameraFormat(module);
    init_QCameraDevice(module);
    init_QAudioFormat(module);
    init_QAudioDevice(module);
    init_QAudioBuffer(module);
    init_QtMultimediaQAudio(module);
    init_QVideoSink(module);
    init_QSoundEffect(module);
    init_QMediaRecorder(module);
    init_QMediaDevices(module);
    init_QMediaCaptureSession(module);
    init_QImageCapture(module);
    init_QCamera(module);
    init_QAudioSource(module);
    init_QAudioSink(module);
    init_QAudioOutput(module);
    init_QAudioInput(module);
    init_QAudioDecoder(module);
    init_QMediaPlayer(module);

    // Register converter for type 'QList<QMediaTimeRange::Interval>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIATIMERANGE_INTERVAL_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaTimeRange_Interval__CppToPython__QList_QMediaTimeRange_Interval_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIATIMERANGE_INTERVAL_IDX], "QList<QMediaTimeRange::Interval>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIATIMERANGE_INTERVAL_IDX],
        _QList_QMediaTimeRange_Interval__PythonToCpp__QList_QMediaTimeRange_Interval_,
        is__QList_QMediaTimeRange_Interval__PythonToCpp__QList_QMediaTimeRange_Interval__Convertible);

    // Register converter for type 'QList<QMediaMetaData::Key>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_KEY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaMetaData_Key__CppToPython__QList_QMediaMetaData_Key_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_KEY_IDX], "QList<QMediaMetaData::Key>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_KEY_IDX],
        _QList_QMediaMetaData_Key__PythonToCpp__QList_QMediaMetaData_Key_,
        is__QList_QMediaMetaData_Key__PythonToCpp__QList_QMediaMetaData_Key__Convertible);

    // Register converter for type 'QHash<QMediaMetaData::Key,QVariant>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QHASH_QMEDIAMETADATA_KEY_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_QMediaMetaData_Key_QVariant__CppToPython__QHash_QMediaMetaData_Key_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QHASH_QMEDIAMETADATA_KEY_QVARIANT_IDX], "QHash<QMediaMetaData::Key,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QHASH_QMEDIAMETADATA_KEY_QVARIANT_IDX],
        _QHash_QMediaMetaData_Key_QVariant__PythonToCpp__QHash_QMediaMetaData_Key_QVariant_,
        is__QHash_QMediaMetaData_Key_QVariant__PythonToCpp__QHash_QMediaMetaData_Key_QVariant__Convertible);

    // Register converter for type 'QList<QMediaFormat::AudioCodec>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_AUDIOCODEC_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaFormat_AudioCodec__CppToPython__QList_QMediaFormat_AudioCodec_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_AUDIOCODEC_IDX], "QList<QMediaFormat::AudioCodec>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_AUDIOCODEC_IDX],
        _QList_QMediaFormat_AudioCodec__PythonToCpp__QList_QMediaFormat_AudioCodec_,
        is__QList_QMediaFormat_AudioCodec__PythonToCpp__QList_QMediaFormat_AudioCodec__Convertible);

    // Register converter for type 'QList<QMediaFormat::FileFormat>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_FILEFORMAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaFormat_FileFormat__CppToPython__QList_QMediaFormat_FileFormat_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_FILEFORMAT_IDX], "QList<QMediaFormat::FileFormat>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_FILEFORMAT_IDX],
        _QList_QMediaFormat_FileFormat__PythonToCpp__QList_QMediaFormat_FileFormat_,
        is__QList_QMediaFormat_FileFormat__PythonToCpp__QList_QMediaFormat_FileFormat__Convertible);

    // Register converter for type 'QList<QMediaFormat::VideoCodec>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_VIDEOCODEC_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaFormat_VideoCodec__CppToPython__QList_QMediaFormat_VideoCodec_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_VIDEOCODEC_IDX], "QList<QMediaFormat::VideoCodec>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAFORMAT_VIDEOCODEC_IDX],
        _QList_QMediaFormat_VideoCodec__PythonToCpp__QList_QMediaFormat_VideoCodec_,
        is__QList_QMediaFormat_VideoCodec__PythonToCpp__QList_QMediaFormat_VideoCodec__Convertible);

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

    // Register converter for type 'QList<QCameraFormat>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERAFORMAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QCameraFormat__CppToPython__QList_QCameraFormat_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERAFORMAT_IDX], "QList<QCameraFormat>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERAFORMAT_IDX],
        _QList_QCameraFormat__PythonToCpp__QList_QCameraFormat_,
        is__QList_QCameraFormat__PythonToCpp__QList_QCameraFormat__Convertible);

    // Register converter for type 'QList<QAudioFormat::SampleFormat>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIOFORMAT_SAMPLEFORMAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QAudioFormat_SampleFormat__CppToPython__QList_QAudioFormat_SampleFormat_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIOFORMAT_SAMPLEFORMAT_IDX], "QList<QAudioFormat::SampleFormat>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIOFORMAT_SAMPLEFORMAT_IDX],
        _QList_QAudioFormat_SampleFormat__PythonToCpp__QList_QAudioFormat_SampleFormat_,
        is__QList_QAudioFormat_SampleFormat__PythonToCpp__QList_QAudioFormat_SampleFormat__Convertible);

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

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

    // Register converter for type 'QList<QAudioDevice>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIODEVICE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QAudioDevice__CppToPython__QList_QAudioDevice_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIODEVICE_IDX], "QList<QAudioDevice>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QAUDIODEVICE_IDX],
        _QList_QAudioDevice__PythonToCpp__QList_QAudioDevice_,
        is__QList_QAudioDevice__PythonToCpp__QList_QAudioDevice__Convertible);

    // Register converter for type 'QList<QCameraDevice>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERADEVICE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QCameraDevice__CppToPython__QList_QCameraDevice_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERADEVICE_IDX], "QList<QCameraDevice>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QCAMERADEVICE_IDX],
        _QList_QCameraDevice__PythonToCpp__QList_QCameraDevice_,
        is__QList_QCameraDevice__PythonToCpp__QList_QCameraDevice__Convertible);

    // Register converter for type 'QList<QImageCapture::FileFormat>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QIMAGECAPTURE_FILEFORMAT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QImageCapture_FileFormat__CppToPython__QList_QImageCapture_FileFormat_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QIMAGECAPTURE_FILEFORMAT_IDX], "QList<QImageCapture::FileFormat>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QIMAGECAPTURE_FILEFORMAT_IDX],
        _QList_QImageCapture_FileFormat__PythonToCpp__QList_QImageCapture_FileFormat_,
        is__QList_QImageCapture_FileFormat__PythonToCpp__QList_QImageCapture_FileFormat__Convertible);

    // Register converter for type 'QList<QMediaMetaData>'.
    SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QMediaMetaData__CppToPython__QList_QMediaMetaData_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_IDX], "QList<QMediaMetaData>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_QtMultimediaTypeConverters[SBK_QTMULTIMEDIA_QLIST_QMEDIAMETADATA_IDX],
        _QList_QMediaMetaData__PythonToCpp__QList_QMediaMetaData_,
        is__QList_QMediaMetaData__PythonToCpp__QList_QMediaMetaData__Convertible);

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

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

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

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_QtMultimediaTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_QtMultimediaTypeConverters);

    // Static field initialization
    init_QVideoFrameFormatStaticFields();
    init_QMediaMetaDataStaticFields();

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

    FinishSignatureInitialization(module, QtMultimedia_SignatureStrings);

    return module;
}
